diff --git a/src/api-objects/include/tradeoptions.hpp b/src/api-objects/include/tradeoptions.hpp
index e3d0543e..6dc7e4b6 100644
--- a/src/api-objects/include/tradeoptions.hpp
+++ b/src/api-objects/include/tradeoptions.hpp
@@ -68,7 +68,7 @@ class TradeOptions {
 
   string str(bool placeRealOrderInSimulationMode) const;
 
-  bool operator==(const TradeOptions &) const = default;
+  bool operator==(const TradeOptions &) const noexcept = default;
 
  private:
   Duration _maxTradeTime = kDefaultTradeDuration;
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index 7e0e56c0..00a65b6a 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -8,6 +8,13 @@ target_link_libraries(coincenter_engine PUBLIC coincenter_api-interface)
 target_link_libraries(coincenter_engine PUBLIC coincenter_objects)
 target_include_directories(coincenter_engine PUBLIC include)
 
+add_unit_test(
+  coincenteroptions_test
+  test/coincenteroptions_test.cpp
+  LIBRARIES
+  coincenter_engine
+)
+
 add_unit_test(
   commandlineoptionsparser_test
   test/commandlineoptionsparser_test.cpp
@@ -57,4 +64,4 @@ add_unit_test(
   test/stringoptionparser_test.cpp
   LIBRARIES
   coincenter_engine
-)
\ No newline at end of file
+)
diff --git a/src/engine/include/balanceperexchangeportfolio.hpp b/src/engine/include/balanceperexchangeportfolio.hpp
index 660e4be2..96957ee7 100644
--- a/src/engine/include/balanceperexchangeportfolio.hpp
+++ b/src/engine/include/balanceperexchangeportfolio.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "cct_const.hpp"
 #include "cct_json.hpp"
 #include "queryresulttypes.hpp"
 #include "simpletable.hpp"
diff --git a/src/engine/include/coincenteroptions.hpp b/src/engine/include/coincenteroptions.hpp
index 384b5a89..76019dbc 100644
--- a/src/engine/include/coincenteroptions.hpp
+++ b/src/engine/include/coincenteroptions.hpp
@@ -1,150 +1,46 @@
 #pragma once
 
-#include <chrono>
 #include <optional>
+#include <ostream>
 #include <string_view>
 #include <utility>
 
-#include "apioutputtype.hpp"
-#include "cct_const.hpp"
+#include "coincentercommandtype.hpp"
+#include "coincenteroptionsdef.hpp"
 #include "commandlineoption.hpp"
-#include "exchangeinfomap.hpp"
 #include "exchangepublicapi.hpp"
-#include "loadconfiguration.hpp"
-#include "static_string_view_helpers.hpp"
-#include "staticcommandlineoptioncheck.hpp"
-#include "stringhelpers.hpp"
 #include "timedef.hpp"
 #include "tradeoptions.hpp"
 #include "withdrawoptions.hpp"
 
 namespace cct {
 
-std::string_view SelectDefaultDataDir() noexcept;
-
-struct CoincenterCmdLineOptions {
-  static constexpr std::string_view kDefaultMonitoringIPAddress = "0.0.0.0";  // in Docker, localhost does not work
-  static constexpr int kDefaultMonitoringPort = 9091;                         // Prometheus default push port
-  static constexpr Duration kDefaultRepeatTime = TimeInS(1);
-
-  static constexpr int64_t kDefaultTradeTimeout =
-      std::chrono::duration_cast<TimeInS>(TradeOptions().maxTradeTime()).count();
-  static constexpr int64_t kMinUpdatePriceTime =
-      std::chrono::duration_cast<TimeInS>(TradeOptions().minTimeBetweenPriceUpdates()).count();
-  static constexpr int64_t kDefaultRepeatDurationSeconds =
-      std::chrono::duration_cast<TimeInS>(kDefaultRepeatTime).count();
-
-  static constexpr std::string_view kOutput1 = "Output format. One of (";
-  static constexpr std::string_view kOutput2 = ") (default configured in general config file)";
-  static constexpr std::string_view kOutput =
-      JoinStringView_v<kOutput1, kApiOutputTypeNoPrintStr, CharToStringView_v<'|'>, kApiOutputTypeTableStr,
-                       CharToStringView_v<'|'>, kApiOutputTypeJsonStr, kOutput2>;
-
-  static constexpr std::string_view kData1 = "Use given 'data' directory instead of the one chosen at build time '";
-  static constexpr std::string_view kData = JoinStringView_v<kData1, kDefaultDataDir, CharToStringView_v<'\''>>;
-
-  static constexpr std::string_view kRepeat1 = "Set delay between each repeat (default: ";
-  static constexpr std::string_view kRepeat2 = "s)";
-
-  static constexpr std::string_view kRepeat =
-      JoinStringView_v<kRepeat1, IntToStringView_v<kDefaultRepeatDurationSeconds>, kRepeat2>;
-
-  static constexpr std::string_view kLastTradesN1 = "Change number of last trades to query (default: ";
-  static constexpr std::string_view kLastTradesN =
-      JoinStringView_v<kLastTradesN1, IntToStringView_v<api::ExchangePublic::kNbLastTradesDefault>,
-                       CharToStringView_v<')'>>;
-
-  static constexpr std::string_view kSmartBuy1 =
-      "Attempt to buy the specified amount in total, on matching exchange accounts (all are considered if none "
-      "provided)."
-      " The base currencies will be chosen according to the '";
-  static constexpr std::string_view kSmartBuy2 = "' array defined in '";
-  static constexpr std::string_view kSmartBuy3 =
-      "' file. "
-      "Standard trade options are compatible to customize the trade, and if enabled, multi trade can be used.";
-  static constexpr std::string_view kSmartBuy =
-      JoinStringView_v<kSmartBuy1, LoadConfiguration::kProdDefaultExchangeConfigFile, kSmartBuy2,
-                       kPreferredPaymentCurrenciesOptName, kSmartBuy3>;
-
-  static constexpr std::string_view kSmartSell1 =
-      "Attempt to sell the specified amount in total (or percentage with '%'), on matching exchange accounts (all are "
-      "considered if none provided)."
-      " The payment currencies will be chosen according to the '";
-  static constexpr std::string_view kSmartSell =
-      JoinStringView_v<kSmartSell1, LoadConfiguration::kProdDefaultExchangeConfigFile, kSmartBuy2,
-                       kPreferredPaymentCurrenciesOptName, kSmartBuy3>;
-
-  static constexpr std::string_view kTradeTimeout1 = "Adjust trade timeout (default: ";
-  static constexpr std::string_view kTradeTimeout2 = "s). Remaining orders will be cancelled after the timeout.";
-  static constexpr std::string_view kTradeTimeout =
-      JoinStringView_v<kTradeTimeout1, IntToStringView_v<kDefaultTradeTimeout>, kTradeTimeout2>;
-
-  static constexpr std::string_view kTradeUpdatePrice1 =
-      "Set the min time allowed between two limit price updates (default: ";
-  static constexpr std::string_view kTradeUpdatePrice2 =
-      "s). Avoids cancelling / placing new orders too often with high volumes which can be counter productive "
-      "sometimes.";
-  static constexpr std::string_view kTradeUpdatePrice =
-      JoinStringView_v<kTradeUpdatePrice1, IntToStringView_v<kMinUpdatePriceTime>, kTradeUpdatePrice2>;
-
-  static constexpr std::string_view kSimulationMode1 = "Activates simulation mode only (default: ";
-  static constexpr std::string_view kSimulationMode2 = TradeOptions().isSimulation() ? "true" : "false";
-  static constexpr std::string_view kSimulationMode3 =
-      "). For some exchanges, exchange can be queried in this "
-      "mode to validate the trade input options.";
-  static constexpr std::string_view kSimulationMode =
-      JoinStringView_v<kSimulationMode1, kSimulationMode2, kSimulationMode3>;
-
-  static constexpr std::string_view kWithdraw1 =
-      "Withdraw amount from exchange 'from' to exchange 'to'."
-      " Amount is gross, including fees, and can be absolute or percentage of all available amount. Address and tag "
-      "will be retrieved"
-      " automatically from destination exchange and can additionally check if it matches an entry in '";
-  static constexpr std::string_view kWithdraw2 = "' file.";
-  static constexpr std::string_view kWithdraw = JoinStringView_v<kWithdraw1, kDepositAddressesFileName, kWithdraw2>;
-
-  static constexpr std::string_view kWithdrawRefreshTime1 =
-      "Time interval for regular withdraw status checking during synchronous withdrawal. Default is ";
-  static constexpr int64_t kDefaultWithdrawRefreshTimeSeconds =
-      std::chrono::duration_cast<TimeInS>(WithdrawOptions().withdrawRefreshTime()).count();
-  static constexpr std::string_view kWithdrawRefreshTime2 = "s.";
-  static constexpr std::string_view kWithdrawRefreshTime =
-      JoinStringView_v<kWithdrawRefreshTime1, IntToStringView_v<kDefaultWithdrawRefreshTimeSeconds>,
-                       kWithdrawRefreshTime2>;
-
-  static constexpr std::string_view kDustSweeper =
-      "Attempts to clean small remaining amount of given currency on each given exchange."
-      " The amount is considered 'small' and eligible for dust sweeper process if the 'dustAmountsThreshold' is "
-      "set in "
-      "the config file for this currency and if starting available amount is lower than this defined threshold."
-      " Dust sweeper process is iterative, involving at most 'dustSweeperMaxNbTrades' max trades to be set as well "
-      "in "
-      "the config file.";
-
-  static constexpr std::string_view kMonitoringPort1 = "Specify port of metric gateway instance (default: ";
-  static constexpr std::string_view kMonitoringPort =
-      JoinStringView_v<kMonitoringPort1, IntToStringView_v<CoincenterCmdLineOptions::kDefaultMonitoringPort>,
-                       CharToStringView_v<')'>>;
-
-  static constexpr std::string_view kMonitoringIP1 = "Specify IP (v4) of metric gateway instance (default: ";
-  static constexpr std::string_view kMonitoringIP =
-      JoinStringView_v<kMonitoringIP1, CoincenterCmdLineOptions::kDefaultMonitoringIPAddress, CharToStringView_v<')'>>;
-
-  static void PrintVersion(std::string_view programName) noexcept;
+class CoincenterCmdLineOptions {
+ public:
+  static std::ostream& PrintVersion(std::string_view programName, std::ostream& os) noexcept;
+
+  constexpr CoincenterCmdLineOptions() noexcept = default;
 
   bool isSmartTrade() const noexcept;
 
-  void mergeGlobalWith(const CoincenterCmdLineOptions& other);
+  TradeOptions computeTradeOptions() const;
+  WithdrawOptions computeWithdrawOptions() const;
+
+  std::string_view getDataDir() const { return dataDir.empty() ? SelectDefaultDataDir() : dataDir; }
+
+  std::pair<std::string_view, CoincenterCommandType> getTradeArgStr() const;
+
+  void mergeGlobalWith(const CoincenterCmdLineOptions& rhs);
 
-  std::string_view dataDir = SelectDefaultDataDir();
+  std::string_view dataDir;
 
   std::string_view apiOutputType;
   std::string_view logConsole;
   std::string_view logFile;
   std::optional<std::string_view> noSecrets;
-  Duration repeatTime = kDefaultRepeatTime;
+  Duration repeatTime = CoincenterCmdLineOptionsDefinitions::kDefaultRepeatTime;
 
-  std::string_view monitoringAddress = kDefaultMonitoringIPAddress;
+  std::string_view monitoringAddress = CoincenterCmdLineOptionsDefinitions::kDefaultMonitoringIPAddress;
   std::string_view monitoringUsername;
   std::string_view monitoringPassword;
 
@@ -185,8 +81,8 @@ struct CoincenterCmdLineOptions {
   Duration minAge{};
   Duration maxAge{};
 
-  std::string_view withdraw;
-  std::string_view withdrawAll;
+  std::string_view withdrawApply;
+  std::string_view withdrawApplyAll;
   std::string_view withdrawFee;
   Duration withdrawRefreshTime{WithdrawOptions().withdrawRefreshTime()};
 
@@ -199,312 +95,25 @@ struct CoincenterCmdLineOptions {
 
   CommandLineOptionalInt repeats;
   int nbLastTrades = api::ExchangePublic::kNbLastTradesDefault;
-  int monitoringPort = kDefaultMonitoringPort;
+  int monitoringPort = CoincenterCmdLineOptionsDefinitions::kDefaultMonitoringPort;
   int orderbookDepth = 0;
 
   bool forceMultiTrade = false;
   bool forceSingleTrade = false;
   bool tradeTimeoutMatch = false;
   bool tradeSim{TradeOptions().isSimulation()};
-  bool tradeAsync = false;  // trade fire and forget mode
+  bool async = false;
   bool help = false;
   bool version = false;
   bool useMonitoring = false;
   bool withBalanceInUse = false;
-  bool withdrawAsync = false;  // withdraw fire and forget mode
-};
 
-template <class OptValueType>
-struct CoincenterAllowedOptions {
-  using CommandLineOptionWithValue = AllowedCommandLineOptionsBase<OptValueType>::CommandLineOptionWithValue;
-
-  static constexpr CommandLineOptionWithValue value[] = {
-      {{{"General", 100}, "help", 'h', "", "Display this information"}, &OptValueType::help},
-      {{{"General", 200}, "--data", "<path/to/data>", CoincenterCmdLineOptions::kData}, &OptValueType::dataDir},
-      {{{"General", 300},
-        "--log",
-        'v',
-        "<levelName|0-6>",
-        "Sets the log level in the console during all execution. "
-        "Possible values are: (off|critical|error|warning|info|debug|trace) or "
-        "(0-6) (overrides .log.console in general config file)"},
-       &OptValueType::logConsole},
-      {{{"General", 400}, "--log-console", "<levelName|0-6>", "Synonym of --log"}, &OptValueType::logConsole},
-      {{{"General", 400},
-        "--log-file",
-        "<levelName|0-6>",
-        "Sets the log level in files during all execution (overrides .log.file in general config file). "
-        "Number of rotating files to keep and their size is configurable in the general config file"},
-       &OptValueType::logFile},
-      {{{"General", 500}, "--output", 'o', "", CoincenterCmdLineOptions::kOutput}, &OptValueType::apiOutputType},
-      {{{"General", 700},
-        "--no-secrets",
-        "<[exch1,...]>",
-        "Do not load secrets for specified exchanges.\n"
-        "If no exchange is specified, no key will be loaded at all"},
-       &OptValueType::noSecrets},
-      {{{"General", 800},
-        "--repeat",
-        'r',
-        "<[n]>",
-        "Indicates how many repeats to perform for mutable data (such as market data)\n"
-        "Modifying requests such as trades and withdraws are not impacted by this option. "
-        "This is useful for monitoring for instance. 'n' is optional, if not given, will repeat endlessly"},
-       &OptValueType::repeats},
-      {{{"General", 900}, "--repeat-time", "<time>", CoincenterCmdLineOptions::kRepeat}, &OptValueType::repeatTime},
-      {{{"General", 1000}, "version", "", "Display program version"}, &OptValueType::version},
-      {{{"Public queries", 2000},
-        "health-check",
-        "<[exch1,...]>",
-        "Simple health check for all exchanges or specified ones"},
-       &OptValueType::healthCheck},
-      {{{"Public queries", 2100},
-        "markets",
-        "<cur1[-cur2][,exch1,...]>",
-        "Print markets involving given currencies for all exchanges, "
-        "or only the specified ones. "
-        "Either a single currency or a full market can be specified."},
-       &OptValueType::markets},
-
-      {{{"Public queries", 2200},
-        "orderbook",
-        "<cur1-cur2[,exch1,...]>",
-        "Print order book of currency pair for all exchanges offering "
-        "this market, or only for specified exchanges."},
-       &OptValueType::orderbook},
-      {{{"Public queries", 2300},
-        "--cur",
-        "<cur>",
-        "If conversion of cur2 into cur is possible (for each exchange), "
-        "prints additional column converted to given asset"},
-       &OptValueType::orderbookCur},
-      {{{"Public queries", 2300}, "--depth", "<n>", "Override default depth of order book"},
-       &OptValueType::orderbookDepth},
-      {{{"Public queries", 2400},
-        "ticker",
-        "<[exch1,...]>",
-        "Print ticker information for all markets for all exchanges,"
-        " or only for specified ones"},
-       &OptValueType::ticker},
-      {{{"Public queries", 2500},
-        "conversion",
-        "<cur1-cur2[,exch1,...]>",
-        "Print fastest conversion path of 'cur1' to 'cur2' "
-        "for given exchanges if possible"},
-       &OptValueType::conversionPath},
-      {{{"Public queries", 2600},
-        "volume-day",
-        "<cur1-cur2[,exch1,...]>",
-        "Print last 24h traded volume for market 'cur1'-'cur2' "
-        "for all exchanges (or specified one)"},
-       &OptValueType::last24hTradedVolume},
-      {{{"Public queries", 2700},
-        "last-trades",
-        "<cur1-cur2[,exch1,...]>",
-        "Print last trades for market 'cur1'-'cur2' "
-        "for all exchanges (or specified one)"},
-       &OptValueType::lastTrades},
-      {{{"Public queries", 2800}, "--n", "<n>", CoincenterCmdLineOptions::kLastTradesN}, &OptValueType::nbLastTrades},
-      {{{"Public queries", 2900},
-        "price",
-        "<cur1-cur2[,exch1,...]>",
-        "Print last price for market 'cur1'-'cur2' "
-        "for all exchanges (or specified one)"},
-       &OptValueType::lastPrice},
-
-      {{{"Private queries", 3000},
-        "balance",
-        "<[cur][,exch1,...]>",
-        "Prints sum of available balance for all selected accounts, "
-        "or all if none given. Optional acronym can be provided, "
-        "in this case a total amount will be printed in this currency "
-        "if conversion is possible."},
-       &OptValueType::balance},
-      {{{"Private queries", 3100}, "--in-use", "", "Include balance in use as well from opened orders"},
-       &OptValueType::withBalanceInUse},
-      {{{"Private queries", 3250},
-        "orders-opened",
-        "<cur1-cur2[,exch1,...]>",
-        "Print opened orders matching selection criteria.\n"
-        "All cur1, cur2 and exchanges are optional, "
-        "returned opened orders will be filtered accordingly."},
-       &OptValueType::openedOrdersInfo},
-      {{{"Private queries", 3260},
-        "orders-cancel",
-        "<cur1-cur2[,exch1,...]>",
-        "Cancel opened orders matching selection criteria.\n"
-        "All cur1, cur2 and exchanges are optional."},
-       &OptValueType::cancelOpenedOrders},
-      {{{"Private queries", 3300},
-        "--id",
-        "<id1,...>",
-        "Only select orders with given ID.\n"
-        "One or several IDs can be given, should be comma separated."},
-       &OptValueType::ids},
-      {{{"Private queries", 3301}, "--min-age", "<time>", "Only select orders with given minimum age."},
-       &OptValueType::minAge},
-      {{{"Private queries", 3302}, "--max-age", "<time>", "Only select orders with given maximum age."},
-       &OptValueType::maxAge},
-      {{{"Private queries", 3400},
-        "deposits",
-        "<cur[,exch1,...]>",
-        "Print recent deposits matching selection criteria.\n"
-        "Currency and exchanges are optional, "
-        "returned deposits will be filtered accordingly."},
-       &OptValueType::recentDepositsInfo},
-      {{{"Private queries", 3600},
-        "--id",
-        "<id1,...>",
-        "Only select deposits with given ID.\n"
-        "One or several IDs can be given, should be comma separated."},
-       &OptValueType::ids},
-      {{{"Private queries", 3601}, "--min-age", "<time>", "Only select deposits with given minimum age."},
-       &OptValueType::minAge},
-      {{{"Private queries", 3602}, "--max-age", "<time>", "Only select deposits with given maximum age."},
-       &OptValueType::maxAge},
-      {{{"Private queries", 3800},
-        "withdraws",
-        "<cur[,exch1,...]>",
-        "Print recent withdraws matching selection criteria.\n"
-        "Currency and exchanges are optional, "
-        "returned withdraws will be filtered accordingly."},
-       &OptValueType::recentWithdrawsInfo},
-      {{{"Private queries", 3900},
-        "--id",
-        "<id1,...>",
-        "Only select withdraws with given ID.\n"
-        "One or several IDs can be given, should be comma separated."},
-       &OptValueType::ids},
-      {{{"Private queries", 3901}, "--min-age", "<time>", "Only select withdraws with given minimum age."},
-       &OptValueType::minAge},
-      {{{"Private queries", 3902}, "--max-age", "<time>", "Only select withdraws with given maximum age."},
-       &OptValueType::maxAge},
-      {{{"Trade", 4000}, "buy", "<amt cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartBuy}, &OptValueType::buy},
-      {{{"Trade", 4000}, "sell", "<amt[%]cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartSell}, &OptValueType::sell},
-      {{{"Trade", 4000},
-        "sell-all",
-        "<cur[,exch1,...]>",
-        "Sell all available amount on matching exchanges (or all if none specified), behaving like sell option."},
-       &OptValueType::sellAll},
-      {{{"Trade", 4000},
-        "trade",
-        "<amt[%]cur1-cur2[,exch1,...]>",
-        "Single trade from given start amount on a list of exchanges, "
-        "or all that have sufficient balance on cur1 if none provided.\n"
-        "Amount can be given as a percentage - in this case the desired percentage "
-        "of available amount on matching exchanges will be traded.\n"
-        "Orders will be placed prioritizing accounts with largest amounts, at limit price by default."},
-       &OptValueType::trade},
-      {{{"Trade", 4000},
-        "trade-all",
-        "<cur1-cur2[,exch1,...]>",
-        "Single trade from available amount from given currency on a list of exchanges,"
-        " or all that have some balance on cur1 if none provided\n"
-        "Order will be placed at limit price by default"},
-       &OptValueType::tradeAll},
-      {{{"Trade", 4010},
-        "--async",
-        "",
-        "Asynchronous trade mode. Trade orders will be sent in fire and forget mode, not following their lifetime "
-        "until either match or cancel occurs.\nThis option is not compatible with multi trade."},
-       &OptValueType::tradeAsync},
-      {{{"Trade", 4010},
-        "--multi-trade",
-        "",
-        "Force activation of multi trade mode for all exchanges, overriding default configuration of config file.\n"
-        "It makes trade in multiple steps possible if exchange does not provide a direct currency market pair.\n"
-        "The conversion path used is always one of the fastest(s). All other trade options apply to one unique trade "
-        "step (for instance, the trade timeout is related to a single trade, not the series of all trades of a multi "
-        "trade)."},
-       &OptValueType::forceMultiTrade},
-      {{{"Trade", 4020},
-        "--no-multi-trade",
-        "",
-        "Force deactivation of multi trade mode for all exchanges, overriding default configuration of config file."},
-       &OptValueType::forceSingleTrade},
-      {{{"Trade", 4030},
-        "--price",
-        "<n|amt cur>",
-        "Manually select trade price, supporting two flavors.\n"
-        "  'n'      : price will be chosen according to the 'n'th price\n"
-        "             of the order book (0: limit price)\n"
-        "  'amt cur': price will be fixed at given price\n"
-        "             Order price will not be continuously updated.\n"
-        "This option is not compatible with '--strategy'"},
-       &OptValueType::tradePrice},
-      {{{"Trade", 4030},
-        "--strategy",
-        "<maker|nibble|taker>",
-        "Customize the order price strategy of the trade\n"
-        "  'maker' : order price set at limit price (default)\n"
-        "  'nibble': order price set at limit price +(buy)/-(sell) 1\n"
-        "  'taker' : order price will be at market price and matched immediately\n"
-        "Order price will be continuously updated and recomputed every '--update-price' step time.\n"
-        "This option is not compatible with '--price'"},
-       &OptValueType::tradeStrategy},
-      {{{"Trade", 4030}, "--timeout", "<time>", CoincenterCmdLineOptions::kTradeTimeout}, &OptValueType::tradeTimeout},
-      {{{"Trade", 4030},
-        "--timeout-match",
-        "",
-        "If after the timeout some amount is still not traded,\n"
-        "force match by placing a remaining order at market price"},
-       &OptValueType::tradeTimeoutMatch},
-      {{{"Trade", 4030}, "--update-price", "<time>", CoincenterCmdLineOptions::kTradeUpdatePrice},
-       &OptValueType::tradeUpdatePrice},
-      {{{"Trade", 4030}, "--sim", "", CoincenterCmdLineOptions::kSimulationMode}, &OptValueType::tradeSim},
-      {{{"Tools", 5000}, "dust-sweeper", "<cur[,exch1,...]>", CoincenterCmdLineOptions::kDustSweeper},
-       &OptValueType::dustSweeper},
-      {{{"Withdraw and deposit", 6000},
-        "deposit-info",
-        "<cur[,exch1,...]>",
-        "Get deposit wallet information for given currency."
-        " If no exchange accounts are given, will query all of them by default"},
-       &OptValueType::depositInfo},
-      {{{"Withdraw and deposit", 6000}, "withdraw-apply", "<amt[%]cur,from-to>", CoincenterCmdLineOptions::kWithdraw},
-       &OptValueType::withdraw},
-      {{{"Withdraw and deposit", 6010},
-        "--async",
-        "",
-        "Initiate withdraw but do not wait for funds' arrival at destination."},
-       &OptValueType::withdrawAsync},
-      {{{"Withdraw and deposit", 6010}, "--refresh-time", "<time>", CoincenterCmdLineOptions::kWithdrawRefreshTime},
-       &OptValueType::withdrawRefreshTime},
-      {{{"Withdraw and deposit", 7000},
-        "withdraw-apply-all",
-        "<cur,from-to>",
-        "Withdraw all available amount instead of a specified amount."},
-       &OptValueType::withdrawAll},
-      {{{"Withdraw and deposit", 8000},
-        "withdraw-fee",
-        "<cur[,exch1,...]>",
-        "Prints withdraw fees of given currency on all supported exchanges,"
-        " or only for the list of specified ones if provided (comma separated)."},
-       &OptValueType::withdrawFee},
-      {{{"Monitoring", 9000},
-        "--monitoring",
-        "",
-        "Progressively send metrics to external instance provided that it's correctly set up "
-        "(Prometheus by default). Refer to the README for more information"},
-       &OptValueType::useMonitoring},
-      {{{"Monitoring", 9000}, "--monitoring-port", "<port>", CoincenterCmdLineOptions::kMonitoringPort},
-       &OptValueType::monitoringPort},
-      {{{"Monitoring", 9000}, "--monitoring-ip", "<IPv4>", CoincenterCmdLineOptions::kMonitoringIP},
-       &OptValueType::monitoringAddress},
-      {{{"Monitoring", 9000},
-        "--monitoring-user",
-        "<username>",
-        "Specify username of metric gateway instance (default: none)"},
-       &OptValueType::monitoringUsername},
-      {{{"Monitoring", 9000},
-        "--monitoring-pass",
-        "<password>",
-        "Specify password of metric gateway instance (default: none)"},
-       &OptValueType::monitoringPassword}};
-
-  static_assert(StaticCommandLineOptionsDuplicatesCheck(std::to_array(value)),
-                "Duplicated option names (short hand flag / long name)");
-  static_assert(StaticCommandLineOptionsDescriptionCheck(std::to_array(value)),
-                "Description of a command line option should not start nor end with a '\n' or space");
+  bool operator==(const CoincenterCmdLineOptions&) const noexcept = default;
+
+ private:
+  static std::string_view SelectDefaultDataDir() noexcept;
+
+  TradeTypePolicy computeTradeTypePolicy() const;
 };
 
 }  // namespace cct
diff --git a/src/engine/include/coincenteroptionsdef.hpp b/src/engine/include/coincenteroptionsdef.hpp
new file mode 100644
index 00000000..dcc90b80
--- /dev/null
+++ b/src/engine/include/coincenteroptionsdef.hpp
@@ -0,0 +1,421 @@
+#pragma once
+
+#include <array>
+#include <chrono>
+#include <cstdint>
+#include <string_view>
+
+#include "apioutputtype.hpp"
+#include "cct_const.hpp"
+#include "commandlineoption.hpp"
+#include "exchangeinfomap.hpp"
+#include "exchangepublicapi.hpp"
+#include "loadconfiguration.hpp"
+#include "static_string_view_helpers.hpp"
+#include "staticcommandlineoptioncheck.hpp"
+#include "timedef.hpp"
+#include "tradeoptions.hpp"
+#include "withdrawoptions.hpp"
+
+namespace cct {
+
+class CoincenterCmdLineOptionsDefinitions {
+ public:
+  static constexpr std::string_view kDefaultMonitoringIPAddress = "0.0.0.0";  // in Docker, localhost does not work
+  static constexpr int kDefaultMonitoringPort = 9091;                         // Prometheus default push port
+  static constexpr Duration kDefaultRepeatTime = TimeInS(1);
+
+  static constexpr int64_t kDefaultTradeTimeout =
+      std::chrono::duration_cast<TimeInS>(TradeOptions().maxTradeTime()).count();
+  static constexpr int64_t kMinUpdatePriceTime =
+      std::chrono::duration_cast<TimeInS>(TradeOptions().minTimeBetweenPriceUpdates()).count();
+  static constexpr int64_t kDefaultRepeatDurationSeconds =
+      std::chrono::duration_cast<TimeInS>(kDefaultRepeatTime).count();
+
+ protected:
+  static constexpr std::string_view kOutput1 = "Output format. One of (";
+  static constexpr std::string_view kOutput2 = ") (default configured in general config file)";
+  static constexpr std::string_view kOutput =
+      JoinStringView_v<kOutput1, kApiOutputTypeNoPrintStr, CharToStringView_v<'|'>, kApiOutputTypeTableStr,
+                       CharToStringView_v<'|'>, kApiOutputTypeJsonStr, kOutput2>;
+
+  static constexpr std::string_view kData1 = "Use given 'data' directory instead of the one chosen at build time '";
+  static constexpr std::string_view kData = JoinStringView_v<kData1, kDefaultDataDir, CharToStringView_v<'\''>>;
+
+  static constexpr std::string_view kRepeat1 = "Set delay between each repeat (default: ";
+  static constexpr std::string_view kRepeat2 = "s)";
+
+  static constexpr std::string_view kRepeat =
+      JoinStringView_v<kRepeat1, IntToStringView_v<kDefaultRepeatDurationSeconds>, kRepeat2>;
+
+  static constexpr std::string_view kLastTradesN1 = "Change number of last trades to query (default: ";
+  static constexpr std::string_view kLastTradesN =
+      JoinStringView_v<kLastTradesN1, IntToStringView_v<api::ExchangePublic::kNbLastTradesDefault>,
+                       CharToStringView_v<')'>>;
+
+  static constexpr std::string_view kSmartBuy1 =
+      "Attempt to buy the specified amount in total, on matching exchange accounts (all are considered if none "
+      "provided)."
+      " The base currencies will be chosen according to the '";
+  static constexpr std::string_view kSmartBuy2 = "' array defined in '";
+  static constexpr std::string_view kSmartBuy3 =
+      "' file. "
+      "Standard trade options are compatible to customize the trade, and if enabled, multi trade can be used.";
+  static constexpr std::string_view kSmartBuy =
+      JoinStringView_v<kSmartBuy1, LoadConfiguration::kProdDefaultExchangeConfigFile, kSmartBuy2,
+                       kPreferredPaymentCurrenciesOptName, kSmartBuy3>;
+
+  static constexpr std::string_view kSmartSell1 =
+      "Attempt to sell the specified amount in total (or percentage with '%'), on matching exchange accounts (all are "
+      "considered if none provided)."
+      " The payment currencies will be chosen according to the '";
+  static constexpr std::string_view kSmartSell =
+      JoinStringView_v<kSmartSell1, LoadConfiguration::kProdDefaultExchangeConfigFile, kSmartBuy2,
+                       kPreferredPaymentCurrenciesOptName, kSmartBuy3>;
+
+  static constexpr std::string_view kTradeTimeout1 = "Adjust trade timeout (default: ";
+  static constexpr std::string_view kTradeTimeout2 = "s). Remaining orders will be cancelled after the timeout.";
+  static constexpr std::string_view kTradeTimeout =
+      JoinStringView_v<kTradeTimeout1, IntToStringView_v<kDefaultTradeTimeout>, kTradeTimeout2>;
+
+  static constexpr std::string_view kTradeUpdatePrice1 =
+      "Set the min time allowed between two limit price updates (default: ";
+  static constexpr std::string_view kTradeUpdatePrice2 =
+      "s). Avoids cancelling / placing new orders too often with high volumes which can be counter productive "
+      "sometimes.";
+  static constexpr std::string_view kTradeUpdatePrice =
+      JoinStringView_v<kTradeUpdatePrice1, IntToStringView_v<kMinUpdatePriceTime>, kTradeUpdatePrice2>;
+
+  static constexpr std::string_view kSimulationMode1 = "Activates simulation mode only (default: ";
+  static constexpr std::string_view kSimulationMode2 = TradeOptions().isSimulation() ? "true" : "false";
+  static constexpr std::string_view kSimulationMode3 =
+      "). For some exchanges, exchange can be queried in this "
+      "mode to validate the trade input options.";
+  static constexpr std::string_view kSimulationMode =
+      JoinStringView_v<kSimulationMode1, kSimulationMode2, kSimulationMode3>;
+
+  static constexpr std::string_view kWithdraw1 =
+      "Withdraw amount from exchange 'from' to exchange 'to'."
+      " Amount is gross, including fees, and can be absolute or percentage of all available amount. Address and tag "
+      "will be retrieved"
+      " automatically from destination exchange and can additionally check if it matches an entry in '";
+  static constexpr std::string_view kWithdraw2 = "' file.";
+  static constexpr std::string_view kWithdraw = JoinStringView_v<kWithdraw1, kDepositAddressesFileName, kWithdraw2>;
+
+  static constexpr std::string_view kWithdrawRefreshTime1 =
+      "Time interval for regular withdraw status checking during synchronous withdrawal. Default is ";
+  static constexpr int64_t kDefaultWithdrawRefreshTimeSeconds =
+      std::chrono::duration_cast<TimeInS>(WithdrawOptions().withdrawRefreshTime()).count();
+  static constexpr std::string_view kWithdrawRefreshTime2 = "s.";
+  static constexpr std::string_view kWithdrawRefreshTime =
+      JoinStringView_v<kWithdrawRefreshTime1, IntToStringView_v<kDefaultWithdrawRefreshTimeSeconds>,
+                       kWithdrawRefreshTime2>;
+
+  static constexpr std::string_view kDustSweeper =
+      "Attempts to clean small remaining amount of given currency on each given exchange."
+      " The amount is considered 'small' and eligible for dust sweeper process if the 'dustAmountsThreshold' is "
+      "set in "
+      "the config file for this currency and if starting available amount is lower than this defined threshold."
+      " Dust sweeper process is iterative, involving at most 'dustSweeperMaxNbTrades' max trades to be set as well "
+      "in "
+      "the config file.";
+
+  static constexpr std::string_view kMonitoringPort1 = "Specify port of metric gateway instance (default: ";
+  static constexpr std::string_view kMonitoringPort =
+      JoinStringView_v<kMonitoringPort1, IntToStringView_v<kDefaultMonitoringPort>, CharToStringView_v<')'>>;
+
+  static constexpr std::string_view kMonitoringIP1 = "Specify IP (v4) of metric gateway instance (default: ";
+  static constexpr std::string_view kMonitoringIP =
+      JoinStringView_v<kMonitoringIP1, kDefaultMonitoringIPAddress, CharToStringView_v<')'>>;
+};
+
+template <class OptValueType>
+struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
+  using CommandLineOptionWithValue = AllowedCommandLineOptionsBase<OptValueType>::CommandLineOptionWithValue;
+
+  static constexpr CommandLineOptionWithValue value[] = {
+      {{{"General", 100}, "help", 'h', "", "Display this information"}, &OptValueType::help},
+      {{{"General", 200}, "--data", "<path/to/data>", kData}, &OptValueType::dataDir},
+      {{{"General", 300},
+        "--log",
+        'v',
+        "<levelName|0-6>",
+        "Sets the log level in the console during all execution. "
+        "Possible values are: (off|critical|error|warning|info|debug|trace) or "
+        "(0-6) (overrides .log.console in general config file)"},
+       &OptValueType::logConsole},
+      {{{"General", 400}, "--log-console", "<levelName|0-6>", "Synonym of --log"}, &OptValueType::logConsole},
+      {{{"General", 400},
+        "--log-file",
+        "<levelName|0-6>",
+        "Sets the log level in files during all execution (overrides .log.file in general config file). "
+        "Number of rotating files to keep and their size is configurable in the general config file"},
+       &OptValueType::logFile},
+      {{{"General", 500}, "--output", 'o', "", kOutput}, &OptValueType::apiOutputType},
+      {{{"General", 700},
+        "--no-secrets",
+        "<[exch1,...]>",
+        "Do not load secrets for specified exchanges.\n"
+        "If no exchange is specified, no key will be loaded at all"},
+       &OptValueType::noSecrets},
+      {{{"General", 800},
+        "--repeat",
+        'r',
+        "<[n]>",
+        "Indicates how many repeats to perform for mutable data (such as market data)\n"
+        "Modifying requests such as trades and withdraws are not impacted by this option. "
+        "This is useful for monitoring for instance. 'n' is optional, if not given, will repeat endlessly"},
+       &OptValueType::repeats},
+      {{{"General", 900}, "--repeat-time", "<time>", kRepeat}, &OptValueType::repeatTime},
+      {{{"General", 1000}, "version", "", "Display program version"}, &OptValueType::version},
+      {{{"Public queries", 2000},
+        "health-check",
+        "<[exch1,...]>",
+        "Simple health check for all exchanges or specified ones"},
+       &OptValueType::healthCheck},
+      {{{"Public queries", 2100},
+        "markets",
+        "<cur1[-cur2][,exch1,...]>",
+        "Print markets involving given currencies for all exchanges, "
+        "or only the specified ones. "
+        "Either a single currency or a full market can be specified."},
+       &OptValueType::markets},
+
+      {{{"Public queries", 2200},
+        "orderbook",
+        "<cur1-cur2[,exch1,...]>",
+        "Print order book of currency pair for all exchanges offering "
+        "this market, or only for specified exchanges."},
+       &OptValueType::orderbook},
+      {{{"Public queries", 2300},
+        "--cur",
+        "<cur>",
+        "If conversion of cur2 into cur is possible (for each exchange), "
+        "prints additional column converted to given asset"},
+       &OptValueType::orderbookCur},
+      {{{"Public queries", 2300}, "--depth", "<n>", "Override default depth of order book"},
+       &OptValueType::orderbookDepth},
+      {{{"Public queries", 2400},
+        "ticker",
+        "<[exch1,...]>",
+        "Print ticker information for all markets for all exchanges,"
+        " or only for specified ones"},
+       &OptValueType::ticker},
+      {{{"Public queries", 2500},
+        "conversion",
+        "<cur1-cur2[,exch1,...]>",
+        "Print fastest conversion path of 'cur1' to 'cur2' "
+        "for given exchanges if possible"},
+       &OptValueType::conversionPath},
+      {{{"Public queries", 2600},
+        "volume-day",
+        "<cur1-cur2[,exch1,...]>",
+        "Print last 24h traded volume for market 'cur1'-'cur2' "
+        "for all exchanges (or specified one)"},
+       &OptValueType::last24hTradedVolume},
+      {{{"Public queries", 2700},
+        "last-trades",
+        "<cur1-cur2[,exch1,...]>",
+        "Print last trades for market 'cur1'-'cur2' "
+        "for all exchanges (or specified one)"},
+       &OptValueType::lastTrades},
+      {{{"Public queries", 2800}, "--n", "<n>", kLastTradesN}, &OptValueType::nbLastTrades},
+      {{{"Public queries", 2900},
+        "price",
+        "<cur1-cur2[,exch1,...]>",
+        "Print last price for market 'cur1'-'cur2' "
+        "for all exchanges (or specified one)"},
+       &OptValueType::lastPrice},
+
+      {{{"Private queries", 3000},
+        "balance",
+        "<[cur][,exch1,...]>",
+        "Prints sum of available balance for all selected accounts, "
+        "or all if none given. Optional acronym can be provided, "
+        "in this case a total amount will be printed in this currency "
+        "if conversion is possible."},
+       &OptValueType::balance},
+      {{{"Private queries", 3100}, "--in-use", "", "Include balance in use as well from opened orders"},
+       &OptValueType::withBalanceInUse},
+      {{{"Private queries", 3250},
+        "orders-opened",
+        "<cur1-cur2[,exch1,...]>",
+        "Print opened orders matching selection criteria.\n"
+        "All cur1, cur2 and exchanges are optional, "
+        "returned opened orders will be filtered accordingly."},
+       &OptValueType::openedOrdersInfo},
+      {{{"Private queries", 3260},
+        "orders-cancel",
+        "<cur1-cur2[,exch1,...]>",
+        "Cancel opened orders matching selection criteria.\n"
+        "All cur1, cur2 and exchanges are optional."},
+       &OptValueType::cancelOpenedOrders},
+      {{{"Private queries", 3300},
+        "--id",
+        "<id1,...>",
+        "Only select orders with given ID.\n"
+        "One or several IDs can be given, should be comma separated."},
+       &OptValueType::ids},
+      {{{"Private queries", 3301}, "--min-age", "<time>", "Only select orders with given minimum age."},
+       &OptValueType::minAge},
+      {{{"Private queries", 3302}, "--max-age", "<time>", "Only select orders with given maximum age."},
+       &OptValueType::maxAge},
+      {{{"Private queries", 3400},
+        "deposits",
+        "<cur[,exch1,...]>",
+        "Print recent deposits matching selection criteria.\n"
+        "Currency and exchanges are optional, "
+        "returned deposits will be filtered accordingly."},
+       &OptValueType::recentDepositsInfo},
+      {{{"Private queries", 3600},
+        "--id",
+        "<id1,...>",
+        "Only select deposits with given ID.\n"
+        "One or several IDs can be given, should be comma separated."},
+       &OptValueType::ids},
+      {{{"Private queries", 3601}, "--min-age", "<time>", "Only select deposits with given minimum age."},
+       &OptValueType::minAge},
+      {{{"Private queries", 3602}, "--max-age", "<time>", "Only select deposits with given maximum age."},
+       &OptValueType::maxAge},
+      {{{"Private queries", 3800},
+        "withdraws",
+        "<cur[,exch1,...]>",
+        "Print recent withdraws matching selection criteria.\n"
+        "Currency and exchanges are optional, "
+        "returned withdraws will be filtered accordingly."},
+       &OptValueType::recentWithdrawsInfo},
+      {{{"Private queries", 3900},
+        "--id",
+        "<id1,...>",
+        "Only select withdraws with given ID.\n"
+        "One or several IDs can be given, should be comma separated."},
+       &OptValueType::ids},
+      {{{"Private queries", 3901}, "--min-age", "<time>", "Only select withdraws with given minimum age."},
+       &OptValueType::minAge},
+      {{{"Private queries", 3902}, "--max-age", "<time>", "Only select withdraws with given maximum age."},
+       &OptValueType::maxAge},
+      {{{"Trade", 4000}, "buy", "<amt cur[,exch1,...]>", kSmartBuy}, &OptValueType::buy},
+      {{{"Trade", 4000}, "sell", "<amt[%]cur[,exch1,...]>", kSmartSell}, &OptValueType::sell},
+      {{{"Trade", 4000},
+        "sell-all",
+        "<cur[,exch1,...]>",
+        "Sell all available amount on matching exchanges (or all if none specified), behaving like sell option."},
+       &OptValueType::sellAll},
+      {{{"Trade", 4000},
+        "trade",
+        "<amt[%]cur1-cur2[,exch1,...]>",
+        "Single trade from given start amount on a list of exchanges, "
+        "or all that have sufficient balance on cur1 if none provided.\n"
+        "Amount can be given as a percentage - in this case the desired percentage "
+        "of available amount on matching exchanges will be traded.\n"
+        "Orders will be placed prioritizing accounts with largest amounts, at limit price by default."},
+       &OptValueType::trade},
+      {{{"Trade", 4000},
+        "trade-all",
+        "<cur1-cur2[,exch1,...]>",
+        "Single trade from available amount from given currency on a list of exchanges,"
+        " or all that have some balance on cur1 if none provided\n"
+        "Order will be placed at limit price by default"},
+       &OptValueType::tradeAll},
+      {{{"Trade", 4010},
+        "--async",
+        "",
+        "Asynchronous trade mode. Trade orders will be sent in fire and forget mode, not following their lifetime "
+        "until either match or cancel occurs.\nThis option is not compatible with multi trade."},
+       &OptValueType::async},
+      {{{"Trade", 4010},
+        "--multi-trade",
+        "",
+        "Force activation of multi trade mode for all exchanges, overriding default configuration of config file.\n"
+        "It makes trade in multiple steps possible if exchange does not provide a direct currency market pair.\n"
+        "The conversion path used is always one of the fastest(s). All other trade options apply to one unique trade "
+        "step (for instance, the trade timeout is related to a single trade, not the series of all trades of a multi "
+        "trade)."},
+       &OptValueType::forceMultiTrade},
+      {{{"Trade", 4020},
+        "--no-multi-trade",
+        "",
+        "Force deactivation of multi trade mode for all exchanges, overriding default configuration of config file."},
+       &OptValueType::forceSingleTrade},
+      {{{"Trade", 4030},
+        "--price",
+        "<n|amt cur>",
+        "Manually select trade price, supporting two flavors.\n"
+        "  'n'      : price will be chosen according to the 'n'th price\n"
+        "             of the order book (0: limit price)\n"
+        "  'amt cur': price will be fixed at given price\n"
+        "             Order price will not be continuously updated.\n"
+        "This option is not compatible with '--strategy'"},
+       &OptValueType::tradePrice},
+      {{{"Trade", 4030},
+        "--strategy",
+        "<maker|nibble|taker>",
+        "Customize the order price strategy of the trade\n"
+        "  'maker' : order price set at limit price (default)\n"
+        "  'nibble': order price set at limit price +(buy)/-(sell) 1\n"
+        "  'taker' : order price will be at market price and matched immediately\n"
+        "Order price will be continuously updated and recomputed every '--update-price' step time.\n"
+        "This option is not compatible with '--price'"},
+       &OptValueType::tradeStrategy},
+      {{{"Trade", 4030}, "--timeout", "<time>", kTradeTimeout}, &OptValueType::tradeTimeout},
+      {{{"Trade", 4030},
+        "--timeout-match",
+        "",
+        "If after the timeout some amount is still not traded,\n"
+        "force match by placing a remaining order at market price"},
+       &OptValueType::tradeTimeoutMatch},
+      {{{"Trade", 4030}, "--update-price", "<time>", kTradeUpdatePrice}, &OptValueType::tradeUpdatePrice},
+      {{{"Trade", 4030}, "--sim", "", kSimulationMode}, &OptValueType::tradeSim},
+      {{{"Tools", 5000}, "dust-sweeper", "<cur[,exch1,...]>", kDustSweeper}, &OptValueType::dustSweeper},
+      {{{"Withdraw and deposit", 6000},
+        "deposit-info",
+        "<cur[,exch1,...]>",
+        "Get deposit wallet information for given currency."
+        " If no exchange accounts are given, will query all of them by default"},
+       &OptValueType::depositInfo},
+      {{{"Withdraw and deposit", 6000}, "withdraw-apply", "<amt[%]cur,from-to>", kWithdraw},
+       &OptValueType::withdrawApply},
+      {{{"Withdraw and deposit", 6010},
+        "--async",
+        "",
+        "Initiate withdraw but do not wait for funds' arrival at destination."},
+       &OptValueType::async},
+      {{{"Withdraw and deposit", 6010}, "--refresh-time", "<time>", kWithdrawRefreshTime},
+       &OptValueType::withdrawRefreshTime},
+      {{{"Withdraw and deposit", 7000},
+        "withdraw-apply-all",
+        "<cur,from-to>",
+        "Withdraw all available amount instead of a specified amount."},
+       &OptValueType::withdrawApplyAll},
+      {{{"Withdraw and deposit", 8000},
+        "withdraw-fee",
+        "<cur[,exch1,...]>",
+        "Prints withdraw fees of given currency on all supported exchanges,"
+        " or only for the list of specified ones if provided (comma separated)."},
+       &OptValueType::withdrawFee},
+      {{{"Monitoring", 9000},
+        "--monitoring",
+        "",
+        "Progressively send metrics to external instance provided that it's correctly set up "
+        "(Prometheus by default). Refer to the README for more information"},
+       &OptValueType::useMonitoring},
+      {{{"Monitoring", 9000}, "--monitoring-port", "<port>", kMonitoringPort}, &OptValueType::monitoringPort},
+      {{{"Monitoring", 9000}, "--monitoring-ip", "<IPv4>", kMonitoringIP}, &OptValueType::monitoringAddress},
+      {{{"Monitoring", 9000},
+        "--monitoring-user",
+        "<username>",
+        "Specify username of metric gateway instance (default: none)"},
+       &OptValueType::monitoringUsername},
+      {{{"Monitoring", 9000},
+        "--monitoring-pass",
+        "<password>",
+        "Specify password of metric gateway instance (default: none)"},
+       &OptValueType::monitoringPassword}};
+
+  static_assert(StaticCommandLineOptionsDuplicatesCheck(std::to_array(value)),
+                "Duplicated option names (short hand flag / long name)");
+  static_assert(StaticCommandLineOptionsDescriptionCheck(std::to_array(value)),
+                "Description of a command line option should not start nor end with a '\n' or space");
+};
+
+}  // namespace cct
diff --git a/src/engine/include/commandlineoption.hpp b/src/engine/include/commandlineoption.hpp
index 3739bd81..b891e0f8 100644
--- a/src/engine/include/commandlineoption.hpp
+++ b/src/engine/include/commandlineoption.hpp
@@ -20,9 +20,10 @@ class CommandHeader {
 
   constexpr int prio() const { return _prio; }
 
-  constexpr auto operator<=>(const CommandHeader& other) const = default;
+  constexpr std::strong_ordering operator<=>(const CommandHeader&) const = default;
 
  private:
+  // Order of members is important because of the default spaceship operator. _prio should be first
   int _prio = 0;
   std::string_view _groupName;
 };
@@ -55,7 +56,7 @@ class CommandLineOption {
 
   constexpr bool hasShortName() const { return _shortName != '\0'; }
 
-  constexpr auto operator<=>(const CommandLineOption& other) const = default;
+  constexpr std::strong_ordering operator<=>(const CommandLineOption&) const = default;
 
  private:
   static constexpr std::string_view kLegacyFullNamePrefixOption = "--";
@@ -85,6 +86,8 @@ class CommandLineOptionalInt {
   constexpr bool isPresent() const { return _state == State::kOptionPresent || _state == State::kValueIsSet; }
   constexpr bool isSet() const { return _state == State::kValueIsSet; }
 
+  bool operator==(const CommandLineOptionalInt&) const noexcept = default;
+
  private:
   int _value = 0;
   State _state = State::kOptionNotPresent;
diff --git a/src/engine/include/commandlineoptionsparser.hpp b/src/engine/include/commandlineoptionsparser.hpp
index 98aab356..ca9f3701 100644
--- a/src/engine/include/commandlineoptionsparser.hpp
+++ b/src/engine/include/commandlineoptionsparser.hpp
@@ -3,11 +3,11 @@
 #include <algorithm>
 #include <functional>
 #include <iterator>
-#include <memory>
 #include <optional>
 #include <ostream>
 #include <span>
 #include <string_view>
+#include <type_traits>
 #include <unordered_map>
 
 #include "cct_cctype.hpp"
@@ -82,7 +82,7 @@ class CommandLineOptionsParser {
   }
 
   void displayHelp(std::string_view programName, std::ostream& stream) const {
-    stream << "usage: " << programName << " <general options> <command(s)>\n";
+    stream << "usage: " << programName << " <general options> [command(s)]\n";
     if (_opts.empty()) {
       return;
     }
@@ -150,11 +150,11 @@ class CommandLineOptionsParser {
     return std::ranges::none_of(_opts, [opt](const auto& cmdLineOpt) { return cmdLineOpt.first.matches(opt); });
   }
 
-  static bool IsOptionPositiveInt(std::string_view opt) { return std::ranges::all_of(opt, isdigit); }
+  static bool AreAllDigits(std::string_view opt) { return std::ranges::all_of(opt, isdigit); }
 
   static bool IsOptionInt(std::string_view opt) {
     return ((opt[0] == '-' || opt[0] == '+') && std::all_of(std::next(opt.begin()), opt.end(), isdigit)) ||
-           IsOptionPositiveInt(opt);
+           AreAllDigits(opt);
   }
 
   CallbackType registerCallback(const CommandLineOption& commandLineOption, CommandLineOptionType prop,
@@ -162,20 +162,22 @@ class CommandLineOptionsParser {
     return [this, &commandLineOption, prop, &data](int& idx, std::span<const char*> argv) {
       if (commandLineOption.matches(argv[idx])) {
         std::visit(overloaded{
-                       // bool value matcher
-                       [&data](bool OptValueType::*arg) { data.*arg = true; },
-
-                       // int value matcher
-                       [&data, &idx, argv, &commandLineOption](int OptValueType::*arg) {
-                         if (idx + 1U < argv.size()) {
-                           std::string_view nextOpt(argv[idx + 1]);
-                           if (IsOptionInt(nextOpt)) {
-                             data.*arg = FromString<int>(nextOpt);
-                             ++idx;
-                             return;
+                       // integral value matcher including bool
+                       [&data, &idx, argv, &commandLineOption](std::integral auto OptValueType::*arg) {
+                         using IntType = std::remove_reference_t<decltype(data.*arg)>;
+                         if constexpr (std::is_same_v<IntType, bool>) {
+                           data.*arg = true;
+                         } else {
+                           if (idx + 1U < argv.size()) {
+                             std::string_view nextOpt(argv[idx + 1]);
+                             if (IsOptionInt(nextOpt)) {
+                               data.*arg = FromString<IntType>(nextOpt);
+                               ++idx;
+                               return;
+                             }
                            }
+                           ThrowExpectingValueException(commandLineOption);
                          }
-                         ThrowExpectingValueException(commandLineOption);
                        },
 
                        // CommandLineOptionalInt value matcher
@@ -262,7 +264,7 @@ class CommandLineOptionsParser {
     LevenshteinDistanceCalculator calc;
     std::ranges::transform(_opts, minDistancesToFullNameOptions.begin(),
                            [argStr, &calc](const auto opt) { return calc(opt.first.fullName(), argStr); });
-    auto optIt = std::ranges::min_element(minDistancesToFullNameOptions);
+    const auto optIt = std::ranges::min_element(minDistancesToFullNameOptions);
     return {optIt - minDistancesToFullNameOptions.begin(), *optIt};
   }
 
diff --git a/src/engine/include/exchangesorchestrator.hpp b/src/engine/include/exchangesorchestrator.hpp
index 7befd1b5..ddab414e 100644
--- a/src/engine/include/exchangesorchestrator.hpp
+++ b/src/engine/include/exchangesorchestrator.hpp
@@ -7,7 +7,6 @@
 #include "market.hpp"
 #include "queryresulttypes.hpp"
 #include "threadpool.hpp"
-#include "tradedamounts.hpp"
 #include "withdrawoptions.hpp"
 
 namespace cct {
diff --git a/src/engine/include/traderesult.hpp b/src/engine/include/traderesult.hpp
index 967c9d14..c5fd8498 100644
--- a/src/engine/include/traderesult.hpp
+++ b/src/engine/include/traderesult.hpp
@@ -32,4 +32,4 @@ class TradeResult {
   MonetaryAmount _from;
 };
 
-}  // namespace cct
\ No newline at end of file
+}  // namespace cct
diff --git a/src/engine/src/coincenter.cpp b/src/engine/src/coincenter.cpp
index f642a42f..a382b1ee 100644
--- a/src/engine/src/coincenter.cpp
+++ b/src/engine/src/coincenter.cpp
@@ -162,7 +162,7 @@ void Coincenter::processCommand(const CoincenterCommand &cmd) {
                                           cmd.tradeOptions());
       break;
     }
-    case CoincenterCommandType::kWithdraw: {
+    case CoincenterCommandType::kWithdrawApply: {
       const auto &fromExchangeName = cmd.exchangeNames().front();
       const auto &toExchangeName = cmd.exchangeNames().back();
       const auto deliveredWithdrawInfoWithExchanges =
diff --git a/src/engine/src/coincentercommand.cpp b/src/engine/src/coincentercommand.cpp
index 1c91fae8..afed84be 100644
--- a/src/engine/src/coincentercommand.cpp
+++ b/src/engine/src/coincentercommand.cpp
@@ -136,7 +136,7 @@ CoincenterCommand& CoincenterCommand::setTradeOptions(TradeOptions&& tradeOption
 }
 
 CoincenterCommand& CoincenterCommand::setWithdrawOptions(const WithdrawOptions& withdrawOptions) {
-  if (_type != CoincenterCommandType::kWithdraw) {
+  if (_type != CoincenterCommandType::kWithdrawApply) {
     throw exception("Withdraw options can only be used for withdraws");
   }
   _specialOptions = withdrawOptions;
@@ -144,7 +144,7 @@ CoincenterCommand& CoincenterCommand::setWithdrawOptions(const WithdrawOptions&
 }
 
 CoincenterCommand& CoincenterCommand::setWithdrawOptions(WithdrawOptions&& withdrawOptions) {
-  if (_type != CoincenterCommandType::kWithdraw) {
+  if (_type != CoincenterCommandType::kWithdrawApply) {
     throw exception("Withdraw options can only be used for withdraws");
   }
   _specialOptions = std::move(withdrawOptions);
@@ -181,7 +181,7 @@ CoincenterCommand& CoincenterCommand::setCur2(CurrencyCode cur2) {
 
 CoincenterCommand& CoincenterCommand::setPercentageAmount(bool value) {
   if (_type != CoincenterCommandType::kBuy && _type != CoincenterCommandType::kSell &&
-      _type != CoincenterCommandType::kTrade && _type != CoincenterCommandType::kWithdraw) {
+      _type != CoincenterCommandType::kTrade && _type != CoincenterCommandType::kWithdrawApply) {
     throw exception("Percentage trade can only be set for trade / buy / sell or withdraw command");
   }
   _isPercentageAmount = value;
diff --git a/src/engine/src/coincentercommands.cpp b/src/engine/src/coincentercommands.cpp
index 7faa5a27..5428dce6 100644
--- a/src/engine/src/coincentercommands.cpp
+++ b/src/engine/src/coincentercommands.cpp
@@ -58,7 +58,7 @@ vector<CoincenterCmdLineOptions> CoincenterCommands::ParseOptions(int argc, cons
     if (groupParsedOptions.help) {
       parser.displayHelp(programName, std::cout);
     } else if (groupParsedOptions.version) {
-      CoincenterCmdLineOptions::PrintVersion(programName);
+      CoincenterCmdLineOptions::PrintVersion(programName, std::cout);
     } else {
       // Only store commands if they are not 'help' nor 'version'
       parsedOptions.push_back(std::move(groupParsedOptions));
@@ -86,60 +86,6 @@ std::pair<OrdersConstraints, ExchangeNames> ParseOrderRequest(const CoincenterCm
       std::get<2>(currenciesPrivateExchangesTuple));
 }
 
-TradeTypePolicy ComputeTradeTypePolicy(const CoincenterCmdLineOptions &cmdLineOptions) {
-  TradeTypePolicy tradeType = TradeTypePolicy::kDefault;
-  if (cmdLineOptions.forceMultiTrade) {
-    if (cmdLineOptions.forceSingleTrade) {
-      throw invalid_argument("Multi & Single trade cannot be forced at the same time");
-    }
-    if (cmdLineOptions.tradeAsync) {
-      throw invalid_argument("Cannot use force multi trade and asynchronous mode at the same time");
-    }
-    tradeType = TradeTypePolicy::kForceMultiTrade;
-  } else if (cmdLineOptions.forceSingleTrade || cmdLineOptions.tradeAsync) {
-    tradeType = TradeTypePolicy::kForceSingleTrade;
-  }
-
-  return tradeType;
-}
-
-TradeOptions ComputeTradeOptions(const CoincenterCmdLineOptions &cmdLineOptions, TradeTypePolicy tradeTypePolicy) {
-  TradeTimeoutAction timeoutAction =
-      cmdLineOptions.tradeTimeoutMatch ? TradeTimeoutAction::kForceMatch : TradeTimeoutAction::kCancel;
-  TradeMode tradeMode = cmdLineOptions.tradeSim ? TradeMode::kSimulation : TradeMode::kReal;
-  TradeSyncPolicy tradeSyncPolicy =
-      cmdLineOptions.tradeAsync ? TradeSyncPolicy::kAsynchronous : TradeSyncPolicy::kSynchronous;
-  if (!cmdLineOptions.tradeStrategy.empty()) {
-    PriceOptions priceOptions(cmdLineOptions.tradeStrategy);
-    return {priceOptions,    timeoutAction,  tradeMode, cmdLineOptions.tradeTimeout, cmdLineOptions.tradeUpdatePrice,
-            tradeTypePolicy, tradeSyncPolicy};
-  }
-  if (!cmdLineOptions.tradePrice.empty()) {
-    MonetaryAmount tradePrice(cmdLineOptions.tradePrice);
-    if (tradePrice.isAmountInteger() && tradePrice.hasNeutralCurrency()) {
-      // Then it must be a relative price
-      RelativePrice relativePrice = static_cast<RelativePrice>(tradePrice.integerPart());
-      PriceOptions priceOptions(relativePrice);
-      return {priceOptions,    timeoutAction,  tradeMode, cmdLineOptions.tradeTimeout, cmdLineOptions.tradeUpdatePrice,
-              tradeTypePolicy, tradeSyncPolicy};
-    }
-    if (cmdLineOptions.isSmartTrade()) {
-      throw invalid_argument("Absolute price is not compatible with smart buy / sell");
-    }
-    PriceOptions priceOptions(tradePrice);
-    return {priceOptions,    timeoutAction,  tradeMode, cmdLineOptions.tradeTimeout, cmdLineOptions.tradeUpdatePrice,
-            tradeTypePolicy, tradeSyncPolicy};
-  }
-  return {timeoutAction,   tradeMode,      cmdLineOptions.tradeTimeout, cmdLineOptions.tradeUpdatePrice,
-          tradeTypePolicy, tradeSyncPolicy};
-}
-
-WithdrawOptions ComputeWithdrawOptions(const CoincenterCmdLineOptions &cmdLineOptions) {
-  WithdrawSyncPolicy withdrawSyncPolicy =
-      cmdLineOptions.withdrawAsync ? WithdrawSyncPolicy::kAsynchronous : WithdrawSyncPolicy::kSynchronous;
-  return {cmdLineOptions.withdrawRefreshTime, withdrawSyncPolicy};
-}
-
 }  // namespace
 
 CoincenterCommands::CoincenterCommands(std::span<const CoincenterCmdLineOptions> cmdLineOptionsSpan) {
@@ -215,32 +161,11 @@ bool CoincenterCommands::addOption(const CoincenterCmdLineOptions &cmdLineOption
       1) {
     throw invalid_argument("Only one trade can be done at a time");
   }
-  std::string_view tradeArgs;
-  bool isTradeAll = !cmdLineOptions.tradeAll.empty();
-  CoincenterCommandType commandType;
-  if (!cmdLineOptions.buy.empty()) {
-    tradeArgs = cmdLineOptions.buy;
-    commandType = CoincenterCommandType::kBuy;
-  } else if (!cmdLineOptions.sellAll.empty()) {
-    tradeArgs = cmdLineOptions.sellAll;
-    commandType = CoincenterCommandType::kSell;
-  } else if (!cmdLineOptions.sell.empty()) {
-    tradeArgs = cmdLineOptions.sell;
-    commandType = CoincenterCommandType::kSell;
-  } else {
-    tradeArgs = isTradeAll ? cmdLineOptions.tradeAll : cmdLineOptions.trade;
-    commandType = CoincenterCommandType::kTrade;
-  }
+  auto [tradeArgs, cmdType] = cmdLineOptions.getTradeArgStr();
   if (!tradeArgs.empty()) {
-    if (!cmdLineOptions.tradeStrategy.empty() && !cmdLineOptions.tradePrice.empty()) {
-      throw invalid_argument("Trade price and trade strategy cannot be set together");
-    }
-
-    TradeTypePolicy tradeTypePolicy = ComputeTradeTypePolicy(cmdLineOptions);
-
-    CoincenterCommand &coincenterCommand = _commands.emplace_back(commandType);
+    CoincenterCommand &coincenterCommand = _commands.emplace_back(cmdType);
 
-    coincenterCommand.setTradeOptions(ComputeTradeOptions(cmdLineOptions, tradeTypePolicy));
+    coincenterCommand.setTradeOptions(cmdLineOptions.computeTradeOptions());
 
     StringOptionParser optParser(tradeArgs);
     if (cmdLineOptions.isSmartTrade()) {
@@ -257,7 +182,7 @@ bool CoincenterCommands::addOption(const CoincenterCmdLineOptions &cmdLineOption
         }
         coincenterCommand.setAmount(amount).setPercentageAmount(isPercentage).setExchangeNames(std::move(exchanges));
       }
-    } else if (isTradeAll) {
+    } else if (!cmdLineOptions.tradeAll.empty()) {
       auto [fromTradeCurrency, toTradeCurrency, exchanges] = optParser.getCurrenciesPrivateExchanges();
       coincenterCommand.setAmount(MonetaryAmount(100, fromTradeCurrency))
           .setPercentageAmount(true)
@@ -323,24 +248,24 @@ bool CoincenterCommands::addOption(const CoincenterCmdLineOptions &cmdLineOption
         .setExchangeNames(std::move(exchanges));
   }
 
-  if (!cmdLineOptions.withdraw.empty()) {
-    StringOptionParser anyParser(cmdLineOptions.withdraw);
+  if (!cmdLineOptions.withdrawApply.empty()) {
+    StringOptionParser anyParser(cmdLineOptions.withdrawApply);
     auto [amountToWithdraw, isPercentageWithdraw, exchanges] = anyParser.getMonetaryAmountFromToPrivateExchange();
-    _commands.emplace_back(CoincenterCommandType::kWithdraw)
+    _commands.emplace_back(CoincenterCommandType::kWithdrawApply)
         .setAmount(amountToWithdraw)
         .setPercentageAmount(isPercentageWithdraw)
         .setExchangeNames(std::move(exchanges))
-        .setWithdrawOptions(ComputeWithdrawOptions(cmdLineOptions));
+        .setWithdrawOptions(cmdLineOptions.computeWithdrawOptions());
   }
 
-  if (!cmdLineOptions.withdrawAll.empty()) {
-    StringOptionParser anyParser(cmdLineOptions.withdrawAll);
+  if (!cmdLineOptions.withdrawApplyAll.empty()) {
+    StringOptionParser anyParser(cmdLineOptions.withdrawApplyAll);
     auto [curToWithdraw, exchanges] = anyParser.getCurrencyFromToPrivateExchange();
-    _commands.emplace_back(CoincenterCommandType::kWithdraw)
+    _commands.emplace_back(CoincenterCommandType::kWithdrawApply)
         .setAmount(MonetaryAmount(100, curToWithdraw))
         .setPercentageAmount(true)
         .setExchangeNames(std::move(exchanges))
-        .setWithdrawOptions(ComputeWithdrawOptions(cmdLineOptions));
+        .setWithdrawOptions(cmdLineOptions.computeWithdrawOptions());
   }
 
   if (!cmdLineOptions.dustSweeper.empty()) {
diff --git a/src/engine/src/coincenterinfo_create.cpp b/src/engine/src/coincenterinfo_create.cpp
index 841fe95a..1abb7639 100644
--- a/src/engine/src/coincenterinfo_create.cpp
+++ b/src/engine/src/coincenterinfo_create.cpp
@@ -25,7 +25,7 @@ namespace cct {
 namespace {
 
 json LoadGeneralConfigAndOverrideOptionsFromCLI(const CoincenterCmdLineOptions &cmdLineOptions) {
-  json generalConfigData = GeneralConfig::LoadFile(cmdLineOptions.dataDir);
+  json generalConfigData = GeneralConfig::LoadFile(cmdLineOptions.getDataDir());
 
   // Override general config options from CLI
   // Use at method to make sure to throw if key is not already present (it should)
@@ -52,7 +52,7 @@ MonitoringInfo MonitoringInfo_Create(std::string_view programName, const Coincen
 
 CoincenterInfo CoincenterInfo_Create(std::string_view programName, const CoincenterCmdLineOptions &cmdLineOptions,
                                      settings::RunMode runMode) {
-  const auto dataDir = cmdLineOptions.dataDir;
+  const auto dataDir = cmdLineOptions.getDataDir();
 
   const json generalConfigData = LoadGeneralConfigAndOverrideOptionsFromCLI(cmdLineOptions);
 
@@ -87,8 +87,7 @@ CoincenterInfo CoincenterInfo_Create(std::string_view programName, const Coincen
 
 ExchangeSecretsInfo ExchangeSecretsInfo_Create(const CoincenterCmdLineOptions &cmdLineOptions) {
   if (cmdLineOptions.noSecrets) {
-    const StringOptionParser anyParser(*cmdLineOptions.noSecrets);
-
+    StringOptionParser anyParser(*cmdLineOptions.noSecrets);
     return ExchangeSecretsInfo(anyParser.getExchanges());
   }
   return {};
diff --git a/src/engine/src/coincenteroptions.cpp b/src/engine/src/coincenteroptions.cpp
index 8cde026c..2540d31f 100644
--- a/src/engine/src/coincenteroptions.cpp
+++ b/src/engine/src/coincenteroptions.cpp
@@ -1,17 +1,24 @@
 #include "coincenteroptions.hpp"
 
 #include <cstdlib>
-#include <iostream>
+#include <ostream>
 #include <string_view>
 
 #include "cct_config.hpp"
 #include "cct_const.hpp"
+#include "coincentercommandtype.hpp"
+#include "coincenteroptionsdef.hpp"
 #include "curlhandle.hpp"
+#include "priceoptions.hpp"
+#include "priceoptionsdef.hpp"
 #include "ssl_sha.hpp"
+#include "tradedefinitions.hpp"
+#include "tradeoptions.hpp"
+#include "withdrawoptions.hpp"
 
 namespace cct {
 
-std::string_view SelectDefaultDataDir() noexcept {
+std::string_view CoincenterCmdLineOptions::SelectDefaultDataDir() noexcept {
   const char* pDataDirEnvValue = std::getenv("CCT_DATA_DIR");
   if (pDataDirEnvValue != nullptr) {
     return pDataDirEnvValue;
@@ -23,50 +30,121 @@ bool CoincenterCmdLineOptions::isSmartTrade() const noexcept {
   return !buy.empty() || !sell.empty() || !sellAll.empty();
 }
 
-void CoincenterCmdLineOptions::PrintVersion(std::string_view programName) noexcept {
-  std::cout << programName << " version " << CCT_VERSION << '\n';
-  std::cout << "compiled with " << CCT_COMPILER_VERSION << " on " << __DATE__ << " at " << __TIME__ << '\n';
-  std::cout << "              " << GetCurlVersionInfo() << '\n';
-  std::cout << "              " << ssl::GetOpenSSLVersion() << '\n';
+std::ostream& CoincenterCmdLineOptions::PrintVersion(std::string_view programName, std::ostream& os) noexcept {
+  os << programName << " version " << CCT_VERSION << '\n';
+  os << "compiled with " << CCT_COMPILER_VERSION << " on " << __DATE__ << " at " << __TIME__ << '\n';
+  os << "              " << GetCurlVersionInfo() << '\n';
+  os << "              " << ssl::GetOpenSSLVersion() << '\n';
+  return os;
 }
 
-void CoincenterCmdLineOptions::mergeGlobalWith(const CoincenterCmdLineOptions& other) {
-  static const auto defaultDataDir = SelectDefaultDataDir();
-  if (other.dataDir != defaultDataDir) {
-    dataDir = other.dataDir;
+void CoincenterCmdLineOptions::mergeGlobalWith(const CoincenterCmdLineOptions& rhs) {
+  static constexpr CoincenterCmdLineOptions kDefaultOpts;
+
+  if (rhs.dataDir != kDefaultOpts.dataDir) {
+    dataDir = rhs.dataDir;
+  }
+  if (rhs.logConsole != kDefaultOpts.logConsole) {
+    logConsole = rhs.logConsole;
   }
-  if (!other.logConsole.empty()) {
-    logConsole = other.logConsole;
+  if (rhs.logFile != kDefaultOpts.logFile) {
+    logFile = rhs.logFile;
   }
-  if (!other.logFile.empty()) {
-    logFile = other.logFile;
+  if (rhs.noSecrets != kDefaultOpts.noSecrets) {
+    noSecrets = rhs.noSecrets;
   }
-  if (other.noSecrets) {
-    noSecrets = other.noSecrets;
+  if (rhs.repeatTime != kDefaultOpts.repeatTime) {
+    repeatTime = rhs.repeatTime;
   }
-  if (other.repeatTime != kDefaultRepeatTime) {
-    repeatTime = other.repeatTime;
+  if (rhs.monitoringAddress != kDefaultOpts.monitoringAddress) {
+    monitoringAddress = rhs.monitoringAddress;
   }
-  if (other.monitoringAddress != kDefaultMonitoringIPAddress) {
-    monitoringAddress = other.monitoringAddress;
+  if (rhs.monitoringUsername != kDefaultOpts.monitoringUsername) {
+    monitoringUsername = rhs.monitoringUsername;
   }
-  if (!other.monitoringUsername.empty()) {
-    monitoringUsername = other.monitoringUsername;
+  if (rhs.monitoringPassword != kDefaultOpts.monitoringPassword) {
+    monitoringPassword = rhs.monitoringPassword;
   }
-  if (!other.monitoringPassword.empty()) {
-    monitoringPassword = other.monitoringPassword;
+
+  if (rhs.repeats != kDefaultOpts.repeats) {
+    repeats = rhs.repeats;
   }
 
-  if (other.repeats.isPresent()) {
-    repeats = other.repeats;
+  if (rhs.monitoringPort != kDefaultOpts.monitoringPort) {
+    monitoringPort = rhs.monitoringPort;
   }
+  if (rhs.useMonitoring != kDefaultOpts.useMonitoring) {
+    useMonitoring = rhs.useMonitoring;
+  }
+}
 
-  if (other.monitoringPort != kDefaultMonitoringPort) {
-    monitoringPort = other.monitoringPort;
+TradeOptions CoincenterCmdLineOptions::computeTradeOptions() const {
+  const TradeTypePolicy tradeTypePolicy = computeTradeTypePolicy();
+  const TradeTimeoutAction timeoutAction =
+      tradeTimeoutMatch ? TradeTimeoutAction::kForceMatch : TradeTimeoutAction::kCancel;
+  const TradeMode tradeMode = tradeSim ? TradeMode::kSimulation : TradeMode::kReal;
+  const TradeSyncPolicy tradeSyncPolicy = async ? TradeSyncPolicy::kAsynchronous : TradeSyncPolicy::kSynchronous;
+
+  if (!tradeStrategy.empty()) {
+    PriceOptions priceOptions(tradeStrategy);
+    return {priceOptions, timeoutAction, tradeMode, tradeTimeout, tradeUpdatePrice, tradeTypePolicy, tradeSyncPolicy};
   }
-  if (other.useMonitoring) {
-    useMonitoring = other.useMonitoring;
+  if (!tradePrice.empty()) {
+    MonetaryAmount tradePriceAmount(tradePrice);
+    if (tradePriceAmount.isAmountInteger() && tradePriceAmount.hasNeutralCurrency()) {
+      // Then it must be a relative price
+      RelativePrice relativePrice = static_cast<RelativePrice>(tradePriceAmount.integerPart());
+      PriceOptions priceOptions(relativePrice);
+      return {priceOptions, timeoutAction, tradeMode, tradeTimeout, tradeUpdatePrice, tradeTypePolicy, tradeSyncPolicy};
+    }
+    if (isSmartTrade()) {
+      throw invalid_argument("Absolute price is not compatible with smart buy / sell");
+    }
+    // fixed price
+    PriceOptions priceOptions(tradePriceAmount);
+    return {priceOptions, timeoutAction, tradeMode, tradeTimeout, tradeUpdatePrice, tradeTypePolicy, tradeSyncPolicy};
   }
+  return {timeoutAction, tradeMode, tradeTimeout, tradeUpdatePrice, tradeTypePolicy, tradeSyncPolicy};
 }
 
+TradeTypePolicy CoincenterCmdLineOptions::computeTradeTypePolicy() const {
+  if (forceMultiTrade) {
+    if (forceSingleTrade) {
+      throw invalid_argument("Multi & Single trade cannot be forced at the same time");
+    }
+    if (async) {
+      throw invalid_argument("Cannot use force multi trade and asynchronous mode at the same time");
+    }
+    return TradeTypePolicy::kForceMultiTrade;
+  }
+  if (forceSingleTrade || async) {
+    return TradeTypePolicy::kForceSingleTrade;
+  }
+
+  return TradeTypePolicy::kDefault;
+}
+
+WithdrawOptions CoincenterCmdLineOptions::computeWithdrawOptions() const {
+  const auto withdrawSyncPolicy = async ? WithdrawSyncPolicy::kAsynchronous : WithdrawSyncPolicy::kSynchronous;
+  return {withdrawRefreshTime, withdrawSyncPolicy};
+}
+
+std::pair<std::string_view, CoincenterCommandType> CoincenterCmdLineOptions::getTradeArgStr() const {
+  if (!tradeStrategy.empty() && !tradePrice.empty()) {
+    throw invalid_argument("Trade price and trade strategy cannot be set together");
+  }
+  if (!buy.empty()) {
+    return {buy, CoincenterCommandType::kBuy};
+  }
+  if (!sell.empty()) {
+    return {sell, CoincenterCommandType::kSell};
+  }
+  if (!sellAll.empty()) {
+    return {sellAll, CoincenterCommandType::kSell};
+  }
+  if (!tradeAll.empty()) {
+    return {tradeAll, CoincenterCommandType::kTrade};
+  }
+  return {trade, CoincenterCommandType::kTrade};
+}
 }  // namespace cct
diff --git a/src/engine/src/queryresultprinter.cpp b/src/engine/src/queryresultprinter.cpp
index 71f6d7b1..06f87101 100644
--- a/src/engine/src/queryresultprinter.cpp
+++ b/src/engine/src/queryresultprinter.cpp
@@ -571,7 +571,7 @@ json WithdrawJson(const DeliveredWithdrawInfo &deliveredWithdrawInfo, MonetaryAm
   out.emplace("receivedTime", ToString(deliveredWithdrawInfo.receivedTime()));
   out.emplace("netReceivedAmount", deliveredWithdrawInfo.receivedAmount().amountStr());
 
-  return ToJson(CoincenterCommandType::kWithdraw, std::move(in), std::move(out));
+  return ToJson(CoincenterCommandType::kWithdrawApply, std::move(in), std::move(out));
 }
 
 json DustSweeperJson(const TradedAmountsVectorWithFinalAmountPerExchange &tradedAmountsVectorWithFinalAmountPerExchange,
@@ -1066,7 +1066,7 @@ void QueryResultPrinter::printWithdraw(const DeliveredWithdrawInfoWithExchanges
     case ApiOutputType::kNoPrint:
       break;
   }
-  logActivity(CoincenterCommandType::kWithdraw, jsonData);
+  logActivity(CoincenterCommandType::kWithdrawApply, jsonData);
 }
 
 void QueryResultPrinter::printDustSweeper(
diff --git a/src/engine/test/coincenteroptions_test.cpp b/src/engine/test/coincenteroptions_test.cpp
new file mode 100644
index 00000000..8c259d00
--- /dev/null
+++ b/src/engine/test/coincenteroptions_test.cpp
@@ -0,0 +1,145 @@
+#include "coincenteroptions.hpp"
+
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <cstdint>
+#include <numeric>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+#include "cct_invalid_argument_exception.hpp"
+#include "monetaryamount.hpp"
+#include "priceoptions.hpp"
+#include "priceoptionsdef.hpp"
+#include "tradeoptions.hpp"
+
+namespace cct {
+
+TEST(CoincenterOptionsTest, PrintVersion) {
+  std::ostringstream os;
+  CoincenterCmdLineOptions::PrintVersion("test", os);
+  EXPECT_TRUE(os.view().starts_with("test"));
+  EXPECT_NE(os.view().find("curl"), std::string_view::npos);
+  EXPECT_NE(os.view().find("OpenSSL"), std::string_view::npos);
+}
+
+class CoincenterCmdLineOptionsTest : public ::testing::Test {
+ protected:
+  CoincenterCmdLineOptions opts;
+};
+
+TEST_F(CoincenterCmdLineOptionsTest, DefaultConstructorShouldValueInitializeAll) {
+  // This test makes sure that are fields are correctly initialized in the default constructor of
+  // CoincenterCmdLineOptions
+  alignas(std::alignment_of_v<CoincenterCmdLineOptions>) std::uint8_t data[sizeof(CoincenterCmdLineOptions)];
+
+  // fill memory with garbage
+  std::iota(std::begin(data), std::end(data), static_cast<std::remove_reference_t<decltype(data[0])>>(0));
+
+  // default construct
+  ::new (data) CoincenterCmdLineOptions;
+
+  const auto *pRhs = reinterpret_cast<const CoincenterCmdLineOptions *>(data);
+
+  EXPECT_EQ(opts, *pRhs);
+
+  static_assert(std::is_trivially_destructible_v<CoincenterCmdLineOptions>,
+                "then destructor should be called (but ideally this type should stay trivially destructible)");
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, MergeGlobal) {
+  opts.async = true;
+  opts.balance = "kraken";
+  opts.noSecrets = "binance,huobi_user1";
+
+  CoincenterCmdLineOptions rhs;
+  rhs.trade = "some value";
+  rhs.nbLastTrades = 42;
+  rhs.repeatTime = std::chrono::minutes(45);
+  rhs.monitoringPort = 999;
+
+  CoincenterCmdLineOptions expected = opts;
+
+  expected.repeatTime = std::chrono::minutes(45);
+  expected.monitoringPort = 999;
+
+  opts.mergeGlobalWith(rhs);
+
+  EXPECT_EQ(expected, opts);
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeOptionsDefault) {
+  EXPECT_EQ(opts.computeTradeOptions(), TradeOptions());
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeTypePolicyInvalid) {
+  opts.forceMultiTrade = true;
+  opts.forceSingleTrade = true;
+  EXPECT_THROW(opts.computeTradeOptions(), invalid_argument);
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeOptionsTradeStrategy) {
+  opts.tradeStrategy = "nibble";
+  opts.tradeTimeoutMatch = true;
+  opts.tradeSim = true;
+  EXPECT_EQ(opts.computeTradeOptions(), TradeOptions(PriceOptions(opts.tradeStrategy), TradeTimeoutAction::kForceMatch,
+                                                     TradeMode::kSimulation, opts.tradeTimeout, opts.tradeUpdatePrice,
+                                                     TradeTypePolicy::kDefault, TradeSyncPolicy::kSynchronous));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeOptionsTradeInvalidTradePrice) {
+  opts.tradePrice = "4.5";
+  opts.sellAll = "USDT";
+  EXPECT_THROW(opts.computeTradeOptions(), invalid_argument);
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeOptionsTradePriceNeutral) {
+  opts.tradePrice = "4";
+  EXPECT_EQ(opts.computeTradeOptions(), TradeOptions(PriceOptions(RelativePrice(MonetaryAmount(4).integerPart()))));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeOptionsTradePrice) {
+  opts.tradePrice = "4XRP";
+  opts.tradeTimeout = std::chrono::seconds(100);
+  opts.async = true;
+  EXPECT_EQ(opts.computeTradeOptions(),
+            TradeOptions(PriceOptions(MonetaryAmount(4, "XRP")), TradeTimeoutAction::kCancel, TradeMode::kReal,
+                         std::chrono::seconds(100), opts.tradeUpdatePrice, TradeTypePolicy::kForceSingleTrade,
+                         TradeSyncPolicy::kAsynchronous));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrDefault) { EXPECT_TRUE(opts.getTradeArgStr().first.empty()); }
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrInvalid) {
+  opts.tradeStrategy = "nibble";
+  opts.tradePrice = "2";
+  EXPECT_THROW(opts.getTradeArgStr(), invalid_argument);
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrTrade) {
+  opts.trade = "some value";
+  EXPECT_EQ(opts.getTradeArgStr(), std::make_pair(opts.trade, CoincenterCommandType::kTrade));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrTradeAll) {
+  opts.tradeAll = "some value";
+  EXPECT_EQ(opts.getTradeArgStr(), std::make_pair(opts.tradeAll, CoincenterCommandType::kTrade));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrSellAll) {
+  opts.sellAll = "some value";
+  EXPECT_EQ(opts.getTradeArgStr(), std::make_pair(opts.sellAll, CoincenterCommandType::kSell));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrSell) {
+  opts.sell = "some value";
+  EXPECT_EQ(opts.getTradeArgStr(), std::make_pair(opts.sell, CoincenterCommandType::kSell));
+}
+
+TEST_F(CoincenterCmdLineOptionsTest, ComputeTradeArgStrBuy) {
+  opts.buy = "some value";
+  EXPECT_EQ(opts.getTradeArgStr(), std::make_pair(opts.buy, CoincenterCommandType::kBuy));
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/engine/test/commandlineoptionsparser_test.cpp b/src/engine/test/commandlineoptionsparser_test.cpp
index a3f0878d..5a52e23e 100644
--- a/src/engine/test/commandlineoptionsparser_test.cpp
+++ b/src/engine/test/commandlineoptionsparser_test.cpp
@@ -185,7 +185,7 @@ TEST_F(CommandLineOptionsParserTest, DurationOptionThrowInvalidTimeUnit1) {
 TEST_F(CommandLineOptionsParserTest, DisplayHelp) {
   std::ostringstream ostream;
   _parser.displayHelp("programName", ostream);
-  constexpr std::string_view expected = R"(usage: programName <general options> <command(s)>
+  constexpr std::string_view expected = R"(usage: programName <general options> [command(s)]
 Options:
 
  General
diff --git a/src/objects/include/coincentercommandtype.hpp b/src/objects/include/coincentercommandtype.hpp
index 42b05765..78d347fe 100644
--- a/src/objects/include/coincentercommandtype.hpp
+++ b/src/objects/include/coincentercommandtype.hpp
@@ -24,7 +24,7 @@ enum class CoincenterCommandType : int8_t {
   kTrade,
   kBuy,
   kSell,
-  kWithdraw,
+  kWithdrawApply,
   kDustSweeper,
 };
 
diff --git a/src/objects/src/coincentercommandtype.cpp b/src/objects/src/coincentercommandtype.cpp
index bdb98fdd..ac614844 100644
--- a/src/objects/src/coincentercommandtype.cpp
+++ b/src/objects/src/coincentercommandtype.cpp
@@ -44,7 +44,7 @@ std::string_view CoincenterCommandTypeToString(CoincenterCommandType type) {
       return "Buy";
     case CoincenterCommandType::kSell:
       return "Sell";
-    case CoincenterCommandType::kWithdraw:
+    case CoincenterCommandType::kWithdrawApply:
       return "Withdraw";
     case CoincenterCommandType::kDustSweeper:
       return "DustSweeper";
@@ -110,7 +110,7 @@ CoincenterCommandType CoincenterCommandTypeFromString(std::string_view str) {
     return CoincenterCommandType::kSell;
   }
   if (str == "Withdraw") {
-    return CoincenterCommandType::kWithdraw;
+    return CoincenterCommandType::kWithdrawApply;
   }
   if (str == "DustSweeper") {
     return CoincenterCommandType::kDustSweeper;