diff --git a/CMakeLists.txt b/CMakeLists.txt
index 10998a38bb8..0d098378f0f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -93,8 +93,8 @@ include(EthExecutableHelper)
 include(EthDependencies)
 include(EthUtils)
 
-hunter_add_package(Boost COMPONENTS filesystem system thread)
-find_package(Boost CONFIG REQUIRED filesystem system thread)
+hunter_add_package(Boost COMPONENTS program_options filesystem system thread)
+find_package(Boost CONFIG REQUIRED program_options filesystem system thread)
 
 hunter_add_package(jsoncpp)
 find_package(jsoncpp CONFIG REQUIRED)
@@ -149,3 +149,8 @@ endif()
 
 # TODO: Split out json_spirit, libscrypt and sec256k1.
 add_subdirectory(utils)
+
+add_executable(main rlp/main.cpp)
+
+add_executable(peer test/unittests/libp2p/peer.cpp)
+add_executable(Options test/tools/libtesteth/Options.cpp)
\ No newline at end of file
diff --git a/eth/CMakeLists.txt b/eth/CMakeLists.txt
index d6676c4227d..3f850f5c5ed 100644
--- a/eth/CMakeLists.txt
+++ b/eth/CMakeLists.txt
@@ -6,9 +6,13 @@ set(
 )
 
 add_executable(eth ${sources})
-target_link_libraries(
-    eth
-    PRIVATE ethereum ethashseal evm web3jsonrpc webthree devcore
+
+
+
+target_link_libraries (
+        eth
+    PRIVATE ethereum ethashseal evm web3jsonrpc webthree devcore Boost::program_options
+
 )
 
 install(TARGETS eth DESTINATION bin)
diff --git a/eth/main.cpp b/eth/main.cpp
index 682036fb101..7ef6983fb21 100644
--- a/eth/main.cpp
+++ b/eth/main.cpp
@@ -30,6 +30,8 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim_all.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 
 #include <libdevcore/FileSystem.h>
 #include <libethashseal/EthashAux.h>
@@ -70,99 +72,11 @@ using namespace dev;
 using namespace dev::p2p;
 using namespace dev::eth;
 using namespace boost::algorithm;
+namespace po = boost::program_options;
 namespace fs = boost::filesystem;
 
 static std::atomic<bool> g_silence = {false};
 
-void help()
-{
-	cout
-		<< "Usage eth [OPTIONS]\n"
-		<< "Options:\n\n"
-		<< "Wallet usage:\n";
-	AccountManager::streamAccountHelp(cout);
-	AccountManager::streamWalletHelp(cout);
-	cout
-		<< "\nClient mode (default):\n"
-		<< "    --mainnet  Use the main network protocol.\n"
-		<< "    --ropsten  Use the Ropsten testnet.\n"
-		<< "    --private <name>  Use a private chain.\n"
-		<< "    --test  Testing mode: Disable PoW and provide test rpc interface.\n"
-		<< "    --config <file>  Configure specialised blockchain using given JSON information.\n"
-		<< "    --oppose-dao-fork  Ignore DAO hard fork (default is to participate).\n\n"
-		<< "    -o,--mode <full/peer>  Start a full node or a peer node (default: full).\n\n"
-		<< "    -j,--json-rpc  Enable JSON-RPC server (default: off).\n"
-		<< "    --ipc  Enable IPC server (default: on).\n"
-		<< "    --ipcpath Set .ipc socket path (default: data directory)\n"
-		<< "    --admin-via-http  Expose admin interface via http - UNSAFE! (default: off).\n"
-		<< "    --no-ipc  Disable IPC server.\n"
-		<< "    --json-rpc-port <n>  Specify JSON-RPC server port (implies '-j', default: " << SensibleHttpPort << ").\n"
-		<< "    --rpccorsdomain <domain>  Domain on which to send Access-Control-Allow-Origin header.\n"
-		<< "    --admin <password>  Specify admin session key for JSON-RPC (default: auto-generated and printed at start-up).\n"
-		<< "    -K,--kill  Kill the blockchain first.\n"
-		<< "    -R,--rebuild  Rebuild the blockchain from the existing database.\n"
-		<< "    --rescue  Attempt to rescue a corrupt database.\n\n"
-		<< "    --import-presale <file>  Import a pre-sale key; you'll need to specify the password to this key.\n"
-		<< "    -s,--import-secret <secret>  Import a secret key into the key store.\n"
-		<< "    --master <password>  Give the master password for the key store. Use --master \"\" to show a prompt.\n"
-		<< "    --password <password>  Give a password for a private key.\n\n"
-		<< "Client transacting:\n"
-		<< "    --ask <wei>  Set the minimum ask gas price under which no transaction will be mined (default " << toString(DefaultGasPrice) << " ).\n"
-		<< "    --bid <wei>  Set the bid gas price to pay for transactions (default " << toString(DefaultGasPrice) << " ).\n"
-		<< "    --unsafe-transactions  Allow all transactions to proceed without verification. EXTREMELY UNSAFE.\n"
-		<< "Client mining:\n"
-		<< "    -a,--address <addr>  Set the author (mining payout) address to given address (default: auto).\n"
-		<< "    -m,--mining <on/off/number>  Enable mining, optionally for a specified number of blocks (default: off).\n"
-		<< "    -f,--force-mining  Mine even when there are no transactions to mine (default: off).\n"
-		<< "    -C,--cpu  When mining, use the CPU.\n"
-		<< "    -t, --mining-threads <n>  Limit number of CPU/GPU miners to n (default: use everything available on selected platform).\n\n"
-		<< "Client networking:\n"
-		<< "    --client-name <name>  Add a name to your client's version string (default: blank).\n"
-		<< "    --bootstrap  Connect to the default Ethereum peer servers (default unless --no-discovery used).\n"
-		<< "    --no-bootstrap  Do not connect to the default Ethereum peer servers (default only when --no-discovery is used).\n"
-		<< "    -x,--peers <number>  Attempt to connect to a given number of peers (default: 11).\n"
-		<< "    --peer-stretch <number>  Give the accepted connection multiplier (default: 7).\n"
-
-		<< "    --public-ip <ip>  Force advertised public IP to the given IP (default: auto).\n"
-		<< "    --listen-ip <ip>(:<port>)  Listen on the given IP for incoming connections (default: 0.0.0.0).\n"
-		<< "    --listen <port>  Listen on the given port for incoming connections (default: 30303).\n"
-		<< "    -r,--remote <host>(:<port>)  Connect to the given remote host (default: none).\n"
-		<< "    --port <port>  Connect to the given remote port (default: 30303).\n"
-		<< "    --network-id <n>  Only connect to other hosts with this network id.\n"
-		<< "    --upnp <on/off>  Use UPnP for NAT (default: on).\n"
-
-		<< "    --peerset <list>  Space delimited list of peers; element format: type:publickey@ipAddress[:port].\n"
-		<< "        Types:\n"
-		<< "        default		Attempt connection when no other peers are available and pinning is disabled.\n"
-		<< "        required		Keep connected at all times.\n"
-// TODO:
-//		<< "	--trust-peers <filename>  Space delimited list of publickeys." << endl
-
-		<< "    --no-discovery  Disable node discovery, implies --no-bootstrap.\n"
-		<< "    --pin  Only accept or connect to trusted peers.\n"
-		<< "    --hermit  Equivalent to --no-discovery --pin.\n"
-		<< "    --sociable  Force discovery and no pinning.\n\n";
-	MinerCLI::streamHelp(cout);
-	cout
-		<< "Import/export modes:\n"
-		<< "    --from <n>  Export only from block n; n may be a decimal, a '0x' prefixed hash, or 'latest'.\n"
-		<< "    --to <n>  Export only to block n (inclusive); n may be a decimal, a '0x' prefixed hash, or 'latest'.\n"
-		<< "    --only <n>  Equivalent to --export-from n --export-to n.\n"
-		<< "    --dont-check  Prevent checking some block aspects. Faster importing, but to apply only when the data is known to be valid.\n\n"
-		<< "    --import-snapshot <path>  Import blockchain and state data from the Parity Warp Sync snapshot." << endl
-		<< "General Options:\n"
-		<< "    -d,--db-path,--datadir <path>  Load database from path (default: " << getDataDir() << ").\n"
-#if ETH_EVMJIT
-		<< "    --vm <vm-kind>  Select VM; options are: interpreter, jit or smart (default: interpreter).\n"
-#endif // ETH_EVMJIT
-		<< "    -v,--verbosity <0 - 9>  Set the log verbosity from 0 to 9 (default: 8).\n"
-		<< "    -V,--version  Show the version and exit.\n"
-		<< "    -h,--help  Show this help message and exit.\n\n"
-		<< "Experimental / Proof of Concept:\n"
-		<< "    --shh  Enable Whisper.\n\n";
-		exit(0);
-}
-
 string ethCredits(bool _interactive = false)
 {
 	std::ostringstream cout;
@@ -305,7 +219,7 @@ int main(int argc, char** argv)
 #else
 	g_logVerbosity = 1;
 #endif
-
+	boost::program_options::option_description desc;
 	/// Operating mode.
 	OperationMode mode = OperationMode::Node;
 //	unsigned prime = 0;
@@ -406,403 +320,599 @@ int main(int argc, char** argv)
 	bool chainConfigIsSet = false;
 	string configJSON;
 	string genesisJSON;
+    po::options_description clientDefaultMode("Client mode (default)");
+	clientDefaultMode.add_options()
+			("format", po::value<string>(), "<format> Set format.")
+			("script", po::value<string>(), "<script> Add script.")
+			("mainnet", "Use the main network protocol.")
+			("ropsten", "Use the Ropsten testnet.")
+			("testnet", "Use the Ropsten testnet.")
+			("gas-floor", po::value<string>(), "Set gasFloor")
+			("private", po::value<string>(), "<name> Use a private chain.")
+			("test", "Testing mode: Disable PoW and provide test rpc interface.")
+			("config", po::value<string>(), "<file> Configure specialised blockchain using given JSON information.")
+			("mode,o", po::value<string>(), "<full/peer>  Start a full node or a peer node (default: full).\n")
+			("json-rpc,j", "Enable JSON-RPC server (default: off).")
+			("ipc", "Enable IPC server (default: on).")
+			("ipcpath", po::value<string>(), "Set .ipc socket path (default: data directory)")
+			("admin-via-http", "Expose admin interface via http - UNSAFE! (default: off).")
+			("no-ipc", "Disable IPC server.")
+			("json-rpc-port", po::value<int>(), "See description under.")
+			("rpccorsdomain", po::value<string>(), "<domain>  Domain on which to send Access-Control-Allow-Origin header.")
+			("admin", po::value<string>(), "<password>  Specify admin session key for JSON-RPC (default: auto-generated and printed at start-up).")
+			("kill,K", "Kill the blockchain first.")
+			("kill-blockchain", "Kill the blockchain first.")
+			("rebuild,R", "Rebuild the blockchain from the existing database.")
+			("rescue", "Attempt to rescue a corrupt database.\n")
+			("import-presale", po::value<string>(), "<file>  Import a pre-sale key; you'll need to specify the password to this key.")
+			("import-secret,s", po::value<string>(), "<secret>  Import a secret key into the key store.")
+			("import-session-secret,S", po::value<string>(), "<secret>  Import a secret session into the key store.")
+			("master", po::value<string>(), "<password>  Give the master password for the key store. Use --master \"\" to show a prompt.")
+			("password", po::value<string>(), "<password>  Give a password for a private key.\n")
+			("extra-data", po::value<string>(), "Set extra data")
+			("genesis", po::value<string>(), "Set genesisJSON")
+			("genesis-json", po::value<string>(), "Set genesisJSON")
+			("json-admin", po::value<string>(), "Set jsonAdmin")
+    ;
+	po::options_description clientTransacting("Client transactions");
+	clientTransacting.add_options()
+			("ask", po::value<string>(), "See description under.")
+			("bid", po::value<string>(), "See description under.")
+			("unsafe-transactions", "Allow all transactions to proceed without verification. EXTREMELY UNSAFE.")
+	;
+	po::options_description clientMining("Client mining");
+	clientMining.add_options()
+			("address,a", po::value<string>(), "<addr>  Set the author (mining payout) address to given address (default: auto).")
+			("author", po::value<string>(), "<addr>  Set the author (mining payout) address to given address (default: auto).")
+			("mining,m", po::value<string>(), "<on/off/number>  Enable mining, optionally for a specified number of blocks (default: off).")
+			("cpu,C", "When mining, use the CPU.")
+			("mining-threads,t", "<n>  Limit number of CPU/GPU miners to n (default: use everything available on selected platform).")
+	;
+	po::options_description clientNetworking("Client networking");
+	clientNetworking.add_options()
+			("client-name", po::value<string>(), "<name>  Add a name to your client's version string (default: blank).")
+			("bootstrap,b",  "Connect to the default Ethereum peer servers (default unless --no-discovery used).")
+			("no-bootstrap",  "Do not connect to the default Ethereum peer servers (default only when --no-discovery is used).")
+			("peers,x", po::value<int>(), "<number>  Attempt to connect to a given number of peers (default: 11).")
+			("peer-stretch", po::value<int>(), "<number>  Give the accepted connection multiplier (default: 7).")
+			("public-ip", po::value<string>(), "<ip>  Force advertised public IP to the given IP (default: auto).")
+			("public", po::value<string>(), "<ip>  Force advertised public IP to the given IP (default: auto).")
+			("listen-ip", po::value<string>(), "<ip>(:<port>)  Listen on the given IP for incoming connections (default: 0.0.0.0).")
+			("listen", po::value<short>(), "<port>  Listen on the given port for incoming connections (default: 30303).")
+			("listen-port", po::value<short>(), "<port>  Listen on the given port for incoming connections (default: 30303).")
+			("remote,r", po::value<string>(), "<host>(:<port>)  Connect to the given remote host (default: none).")
+			("port", po::value<short>(), "<port>  Connect to the given remote port (default: 30303).")
+			("network-id", po::value<string>(), "<n>  Only connect to other hosts with this network id.")
+			("upnp", po::value<string>(), "<on/off>  Use UPnP for NAT (default: on).")
+			("peerset", po::value<string>(), "<list>  Space delimited list of peers; element format: type:publickey@ipAddress[:port].\n        Types:\n        default      Attempt connection when no other peers are available and pinning is disabled.\n        required	    Keep connected at all times.\n")
+			// TODO:
+			//		<< "	--trust-peers <filename>  Space delimited list of publickeys." << endl
+			("no-discovery",  "Disable node discovery, implies --no-bootstrap.")
+			("pin",  "Only accept or connect to trusted peers.")
+			("hermit",  "Equivalent to --no-discovery --pin.")
+			("sociable",  "Force discovery and no pinning.\n")
+	;
+	po::options_description importExportMode("Import/export mode");
+	importExportMode.add_options()
+			("from", po::value<string>(), "<n>  Export only from block n; n may be a decimal, a '0x' prefixed hash, or 'latest'.")
+			("to", po::value<string>(), "<n>  Export only to block n (inclusive); n may be a decimal, a '0x' prefixed hash, or 'latest'.")
+			("only", po::value<string>(), "<n>  Equivalent to --export-from n --export-to n.")
+			("dont-check", "Prevent checking some block aspects. Faster importing, but to apply only when the data is known to be valid.\n")
+			("import-snapshot", po::value<string>(), "<path>  Import blockchain and state data from the Parity Warp Sync snapshot.")
+	;
+	po::options_description generalOptions("General Options");
+	generalOptions.add_options()
+			("db-path,d", po::value<string>(), "See description under.")
+			("datadir", po::value<string>(), "See description under.")
+			("path", po::value<string>(), "See description under.")
+			#if ETH_EVMJIT
+			("vm", "<vm-kind>  Select VM; options are: interpreter, jit or smart (default: interpreter)")
+			#endif // ETH_EVMJIT
+			("verbosity,v", po::value<int>(), "<0 - 9>  Set the log verbosity from 0 to 9 (default: 8).")
+			("version,V",  "Show the version and exit.")
+			("help,h",  "Show this help message and exit.\n")
+
+	;
+	po::options_description experimentalProofOfConcept("Experimental / Proof of Concept");
+	experimentalProofOfConcept.add_options()
+			("shh", "Enable Whisper.\n")
+	;
+	po::options_description allowedOptions("Allowed options");
+	allowedOptions.add(clientDefaultMode).add(clientTransacting).add(clientMining).add(clientNetworking).add(importExportMode).add(generalOptions);
+	int ac = 1;
 	for (int i = 1; i < argc; ++i)
 	{
 		string arg = argv[i];
 		if (m.interpretOption(i, argc, argv))
 		{
-		}
-		else if (arg == "--listen-ip" && i + 1 < argc)
-		{
-			listenIP = argv[++i];
-			listenSet = true;
-		}
-		else if ((arg == "--listen" || arg == "--listen-port") && i + 1 < argc)
-		{
-			listenPort = (short)atoi(argv[++i]);
-			listenSet = true;
-		}
-		else if ((arg == "--public-ip" || arg == "--public") && i + 1 < argc)
-		{
-			publicIP = argv[++i];
-		}
-		else if ((arg == "-r" || arg == "--remote") && i + 1 < argc)
-		{
-			string host = argv[++i];
-			string::size_type found = host.find_first_of(':');
-			if (found != std::string::npos)
-			{
-				remoteHost = host.substr(0, found);
-				remotePort = (short)atoi(host.substr(found + 1, host.length()).c_str());
-			}
-			else
-				remoteHost = host;
-		}
-		else if (arg == "--port" && i + 1 < argc)
-		{
-			remotePort = (short)atoi(argv[++i]);
-		}
-		else if (arg == "--password" && i + 1 < argc)
-			passwordsToNote.push_back(argv[++i]);
-		else if (arg == "--master" && i + 1 < argc)
-		{
-			masterPassword = argv[++i];
-			masterSet = true;
+			continue;
 		}
 		else if ((arg == "-I" || arg == "--import" || arg == "import") && i + 1 < argc)
 		{
 			mode = OperationMode::Import;
 			filename = argv[++i];
 		}
-		else if (arg == "--dont-check")
-			safeImport = true;
 		else if ((arg == "-E" || arg == "--export" || arg == "export") && i + 1 < argc)
 		{
 			mode = OperationMode::Export;
 			filename = argv[++i];
 		}
-		else if (arg == "--script" && i + 1 < argc)
-			scripts.push_back(argv[++i]);
-		else if (arg == "--format" && i + 1 < argc)
+		else if (arg == "--dont-check" || arg == "-K" || arg == "--kill-blockchain" || arg == "--kill" ||
+				 arg == "-R" || arg == "--rebuild" || arg == "--rescue" || arg == "--mainnet" ||
+				 arg == "--ropsten" || arg == "--testnet" || arg == "-b" || arg == "--bootstrap" ||
+				 arg == "--no-bootstrap" || arg == "--no-discovery" || arg == "--pin" ||
+				 arg == "--hermit" || arg == "--unsafe-transactions" || arg == "-j" || arg == "--json-rpc" ||
+				 arg == "--admin-via-http" || arg == "--ipc" || arg == "--no-ipc" || arg == "--shh" || arg == "-h" ||
+				 arg == "--help" || arg == "-V" || arg == "--version"|| arg == "--test") {
+			argv[ac] = argv[i];
+			ac++;
+			i++;
+		}
+		else if ((arg == "--independent" || arg == "--private" || arg == "--network-id" || arg == "--upnp" ||
+				  arg == "--only" || arg == "--from" || arg == "--to" || arg == "--format" || arg == "--script" ||
+				  arg == "--master" || arg == "--password" || arg == "--port" || arg == "-r" || arg == "--remote" ||
+				  arg == "--listen-ip" || arg == "--listen-port" || arg == "--listen" || arg == "--public-ip" ||
+				  arg == "--public" || arg == "--client-name" || arg == "-a" || arg == "--address" || arg == "--author" ||
+				  arg == "-a" || arg == "--address" || arg == "--author" || arg == "-S" || arg == "--import-session-secret" ||
+				  arg == "-s" || arg == "--import-secret" || arg == "-d" || arg == "--path" ||
+				  arg == "--db-path" || arg == "--datadir" || arg == "--ipcpath" || arg == "--genesis-json" || arg == "--genesis" ||
+				  arg == "--config" || arg == "--extra-data" || arg == "--gas-floor" || arg == "--ask" || arg == "--bid" ||
+				  arg == "-m" || arg == "--mining" || arg == "--import-presale" || arg == "-j" || arg == "--json-rpc" ||
+				  arg == "--json-rpc-port" || arg == "--rpccorsdomain" || arg == "--json-admin" ||
+				  arg == "-v" || arg == "--verbosity" || arg == "-x" || arg == "--peers" ||
+				  arg == "--peerset" || arg == "-o" || arg == "--mode" || (arg == std::string("--import-snapshot"))
+				                                                          ) && i + 1 < argc) {
+			argv[ac] = argv[i];
+			ac++;
+			i++;
+			argv[ac] = argv[i];
+			ac++;
+			continue;
+		}
+#if ETH_EVMJIT
+		else if (arg == "--vm" && i + 1 < argc)
 		{
-			string m = argv[++i];
-			if (m == "binary")
-				exportFormat = Format::Binary;
-			else if (m == "hex")
-				exportFormat = Format::Hex;
-			else if (m == "human")
-				exportFormat = Format::Human;
-			else
-			{
-				cerr << "Bad " << arg << " option: " << m << "\n";
-				return -1;
-			}
+			argv[ac] = argv[i];
+			ac++;
+			i++;
+			argv[ac] = argv[i];
+			ac++;
+			string vmKind = argv[++i];
 		}
-		else if (arg == "--to" && i + 1 < argc)
-			exportTo = argv[++i];
-		else if (arg == "--from" && i + 1 < argc)
-			exportFrom = argv[++i];
-		else if (arg == "--only" && i + 1 < argc)
-			exportTo = exportFrom = argv[++i];
-		else if (arg == "--upnp" && i + 1 < argc)
+#endif
+		else
 		{
-			string m = argv[++i];
-			if (isTrue(m))
-				upnp = true;
-			else if (isFalse(m))
-				upnp = false;
+			cerr << "Invalid argument: " << arg << "\n";
+			exit(-1);
+		}
+	}
+	po::variables_map vm;
+	po::store(po::parse_command_line(ac, argv, allowedOptions), vm);
+	po::notify(vm);
+#if ETH_EVMJIT
+	if (vm.count("vm"))
+		{
+			string vmKind = vm["vm"].as<string>();
+			if (vmKind == "interpreter")
+				VMFactory::setKind(VMKind::Interpreter);
+			else if (vmKind == "jit")
+				VMFactory::setKind(VMKind::JIT);
+			else if (vmKind == "smart")
+				VMFactory::setKind(VMKind::Smart);
 			else
 			{
-				cerr << "Bad " << arg << " option: " << m << "\n";
+				cerr << "Unknown VM kind: " << vmKind << "\n";
 				return -1;
 			}
 		}
-		else if (arg == "--network-id" && i + 1 < argc)
-			try {
-				networkID = stol(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
-		else if (arg == "--private" && i + 1 < argc)
-			try {
-				privateChain = argv[++i];
-			}
-			catch (...)
+#endif
+	if (vm.count(std::string("import-snapshot")))
+	{
+		mode = OperationMode::ImportSnapshot;
+		filename = vm[std::string("import-snapshot")].as<string>();
+	}
+	if (vm.count("shh"))
+		useWhisper = true;
+	if (vm.count("version"))
+		version();
+	if (vm.count("test"))
+	{
+		testingMode = true;
+		enableDiscovery = false;
+		disableDiscovery = true;
+		noPinning = true;
+		bootstrap = false;
+	}
+	if (vm.count("verbosity"))
+		g_logVerbosity = vm["verbosity"].as<int>();
+	if (vm.count("peers"))
+		peers = vm["peers"].as<int>();
+	if (vm.count("peer-stretch"))
+		peerStretch = vm["peer-stretch"].as<int>();
+	if (vm.count("peerset"))
+	{
+		string peerset = vm["peerset"].as<string>();
+		if (peerset.empty())
+		{
+			cerr << "--peerset argument must not be empty";
+			return -1;
+		}
+
+		vector<string> each;
+		boost::split(each, peerset, boost::is_any_of("\t "));
+		for (auto const& p: each)
+		{
+			string type;
+			string pubk;
+			string hostIP;
+			unsigned short port = c_defaultListenPort;
+
+			// type:key@ip[:port]
+			vector<string> typeAndKeyAtHostAndPort;
+			boost::split(typeAndKeyAtHostAndPort, p, boost::is_any_of(":"));
+			if (typeAndKeyAtHostAndPort.size() < 2 || typeAndKeyAtHostAndPort.size() > 3)
+				continue;
+
+			type = typeAndKeyAtHostAndPort[0];
+			if (typeAndKeyAtHostAndPort.size() == 3)
+				port = (uint16_t)atoi(typeAndKeyAtHostAndPort[2].c_str());
+
+			vector<string> keyAndHost;
+			boost::split(keyAndHost, typeAndKeyAtHostAndPort[1], boost::is_any_of("@"));
+			if (keyAndHost.size() != 2)
+				continue;
+			pubk = keyAndHost[0];
+			if (pubk.size() != 128)
+				continue;
+			hostIP = keyAndHost[1];
+
+			// todo: use Network::resolveHost()
+			if (hostIP.size() < 4 /* g.it */)
+				continue;
+
+			bool required = type == "required";
+			if (!required && type != "default")
+				continue;
+
+			Public publicKey(fromHex(pubk));
+			try
 			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
-		else if (arg == "--independent" && i + 1 < argc)
-			try {
-				privateChain = argv[++i];
-				noPinning = enableDiscovery = true;
+				preferredNodes[publicKey] = make_pair(NodeIPEndpoint(bi::address::from_string(hostIP), port, port), required);
 			}
 			catch (...)
 			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
+				cerr << "Unrecognized peerset: " << peerset << "\n";
 				return -1;
 			}
-		else if (arg == "-K" || arg == "--kill-blockchain" || arg == "--kill")
-			withExisting = WithExisting::Kill;
-		else if (arg == "-R" || arg == "--rebuild")
-			withExisting = WithExisting::Verify;
-		else if (arg == "-R" || arg == "--rescue")
-			withExisting = WithExisting::Rescue;
-		else if (arg == "--client-name" && i + 1 < argc)
-			clientName = argv[++i];
-		else if ((arg == "-a" || arg == "--address" || arg == "--author") && i + 1 < argc)
+		}
+	}
+	if (vm.count("mode"))
+	{
+		string m = vm["mode"].as<string>();
+		if (m == "full")
+			nodeMode = NodeMode::Full;
+		else if (m == "peer")
+			nodeMode = NodeMode::PeerServer;
+		else
+		{
+			cerr << "Unknown mode: " << m << "\n";
+			return -1;
+		}
+	}
+	if (vm.count("import-presale"))
+		presaleImports.push_back(vm["import-presale"].as<string>());
+	if (vm.count("json-rpc"))
+		jsonRPCURL = jsonRPCURL == -1 ? SensibleHttpPort : jsonRPCURL;
+	if (vm.count("admin-via-http"))
+		adminViaHttp = true;
+	if (vm.count("json-rpc-port"))
+		jsonRPCURL = vm["json-rpc-port"].as<int>();
+	if (vm.count("rpccorsdomain"))
+		rpcCorsDomain = vm["rpccorsdomain"].as<string>();
+	if (vm.count("json-admin"))
+		jsonAdmin = vm["json-admin"].as<string>();
+	if (vm.count("ipc"))
+		ipc = true;
+	if (vm.count("no-ipc"))
+		ipc = false;
+	if (vm.count("mining"))
+	{
+		string m = vm["mining"].as<string>();
+		if (isTrue(m))
+			mining = ~(unsigned)0;
+		else if (isFalse(m))
+			mining = 0;
+		else
 			try {
-				author = h160(fromHex(argv[++i], WhenError::Throw));
-			}
-			catch (BadHexCharacter&)
-			{
-				cerr << "Bad hex in " << arg << " option: " << argv[i] << "\n";
-				return -1;
+				mining = stoi(m);
 			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
+			catch (...) {
+				cerr << "Unknown --mining option: " << m << "\n";
 				return -1;
 			}
-		else if ((arg == "-s" || arg == "--import-secret") && i + 1 < argc)
+	}
+	if (vm.count("bootstrap"))
+		bootstrap = true;
+	if (vm.count("no-bootstrap"))
+		bootstrap = false;
+	if (vm.count("no-discovery"))
+	{
+		disableDiscovery = true;
+		bootstrap = false;
+	}
+	if (vm.count("pin"))
+		pinning = true;
+	if (vm.count("hermit"))
+		pinning = disableDiscovery = true;
+	if (vm.count("sociable"))
+		noPinning = enableDiscovery = true;
+	if (vm.count("unsafe-transactions"))
+		alwaysConfirm = false;
+	if (vm.count("path"))
+		setDataDir(vm["path"].as<string>());
+	if (vm.count("db-path"))
+	setDataDir(vm["db-path"].as<string>());
+	if (vm.count("datadir"))
+		setDataDir(vm["datadir"].as<string>());
+	if (vm.count("ipcpath"))
+		setIpcPath(vm["ipcpath"].as<string>());
+	if (vm.count("genesis"))
+	{
+		try
 		{
-			Secret s(fromHex(argv[++i]));
-			toImport.emplace_back(s);
+			genesisJSON = contentsString(vm["genesis"].as<string>());
 		}
-		else if ((arg == "-S" || arg == "--import-session-secret") && i + 1 < argc)
+		catch (...)
 		{
-			Secret s(fromHex(argv[++i]));
-			toImport.emplace_back(s);
+			cerr << "Bad --genesis option: " << vm["genesis"].as<string>() << "\n";
+			return -1;
 		}
-		else if ((arg == "-d" || arg == "--path" || arg == "--db-path" || arg == "--datadir") && i + 1 < argc)
-			setDataDir(argv[++i]);
-		else if (arg == "--ipcpath" && i + 1 < argc )
-			setIpcPath(argv[++i]);
-		else if ((arg == "--genesis-json" || arg == "--genesis") && i + 1 < argc)
+	}
+	if (vm.count("genesis-json"))
+	{
+		try
 		{
-			try
-			{
-				genesisJSON = contentsString(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
+			genesisJSON = contentsString(vm["genesis-json"].as<string>());
 		}
-		else if (arg == "--config" && i + 1 < argc)
+		catch (...)
 		{
-			try
-			{
-				configJSON = contentsString(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
+			cerr << "Bad --genesis-json option: " << vm["genesis-json"].as<string>() << "\n";
+			return -1;
 		}
-		else if (arg == "--extra-data" && i + 1 < argc)
+	}
+	if (vm.count("config"))
+	{
+		try
 		{
-			try
-			{
-				extraData = fromHex(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
+			configJSON = contentsString(vm["config"].as<string>());
 		}
-		else if (arg == "--gas-floor" && i + 1 < argc)
-			gasFloor = u256(argv[++i]);
-		else if (arg == "--mainnet")
+		catch (...)
 		{
-			chainParams = ChainParams(genesisInfo(eth::Network::MainNetwork), genesisStateRoot(eth::Network::MainNetwork));
-			chainConfigIsSet = true;
+			cerr << "Bad --config option: " << vm["config"].as<string>() << "\n";
+			return -1;
 		}
-		else if (arg == "--ropsten" || arg == "--testnet")
+	}
+	if (vm.count("extra-data"))
+	{
+		try
 		{
-			chainParams = ChainParams(genesisInfo(eth::Network::Ropsten), genesisStateRoot(eth::Network::Ropsten));
-			chainConfigIsSet = true;
+			extraData = fromHex(vm["extra-data"].as<string>());
 		}
-		else if (arg == "--ask" && i + 1 < argc)
+		catch (...)
 		{
-			try
-			{
-				askPrice = u256(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
+			cerr << "Bad " << "--extra-data" << " option: " << vm["extra-data"].as<string>() << "\n";
+			return -1;
 		}
-		else if (arg == "--bid" && i + 1 < argc)
+	}
+	if (vm.count("gas-floor"))
+		gasFloor = u256(vm["gas-floor"].as<string>());
+	if (vm.count("mainnet"))
+	{
+		chainParams = ChainParams(genesisInfo(eth::Network::MainNetwork), genesisStateRoot(eth::Network::MainNetwork));
+		chainConfigIsSet = true;
+	}
+	if (vm.count("ropsten") || vm.count("testnet"))
+	{
+		chainParams = ChainParams(genesisInfo(eth::Network::Ropsten), genesisStateRoot(eth::Network::Ropsten));
+		chainConfigIsSet = true;
+	}
+	if (vm.count("ask"))
+	{
+		try
 		{
-			try
-			{
-				bidPrice = u256(argv[++i]);
-			}
-			catch (...)
-			{
-				cerr << "Bad " << arg << " option: " << argv[i] << "\n";
-				return -1;
-			}
+			askPrice = u256(vm["ask"].as<string>());
 		}
-		else if ((arg == "-m" || arg == "--mining") && i + 1 < argc)
+		catch (...)
 		{
-			string m = argv[++i];
-			if (isTrue(m))
-				mining = ~(unsigned)0;
-			else if (isFalse(m))
-				mining = 0;
-			else
-				try {
-					mining = stoi(m);
-				}
-				catch (...) {
-					cerr << "Unknown " << arg << " option: " << m << "\n";
-					return -1;
-				}
+			cerr << "Bad --ask option: " << vm["ask"].as<string>() << "\n";
+			return -1;
 		}
-		else if (arg == "-b" || arg == "--bootstrap")
-			bootstrap = true;
-		else if (arg == "--no-bootstrap")
-			bootstrap = false;
-		else if (arg == "--no-discovery")
+	}
+	if (vm.count("bid"))
+	{
+		try
 		{
-			disableDiscovery = true;
-			bootstrap = false;
+			bidPrice = u256(vm["bid"].as<string>());
 		}
-		else if (arg == "--pin")
-			pinning = true;
-		else if (arg == "--hermit")
-			pinning = disableDiscovery = true;
-		else if (arg == "--sociable")
-			noPinning = enableDiscovery = true;
-		else if (arg == "--unsafe-transactions")
-			alwaysConfirm = false;
-		else if (arg == "--import-presale" && i + 1 < argc)
-			presaleImports.push_back(argv[++i]);
-
-		else if ((arg == "-j" || arg == "--json-rpc"))
-			jsonRPCURL = jsonRPCURL == -1 ? SensibleHttpPort : jsonRPCURL;
-		else if (arg == "--admin-via-http")
-			adminViaHttp = true;
-		else if (arg == "--json-rpc-port" && i + 1 < argc)
-			jsonRPCURL = atoi(argv[++i]);
-		else if (arg == "--rpccorsdomain" && i + 1 < argc)
-			rpcCorsDomain = argv[++i];
-		else if (arg == "--json-admin" && i + 1 < argc)
-			jsonAdmin = argv[++i];
-		else if (arg == "--ipc")
-			ipc = true;
-		else if (arg == "--no-ipc")
-			ipc = false;
-
-		else if ((arg == "-v" || arg == "--verbosity") && i + 1 < argc)
-			g_logVerbosity = atoi(argv[++i]);
-		else if ((arg == "-x" || arg == "--peers") && i + 1 < argc)
-			peers = atoi(argv[++i]);
-		else if (arg == "--peer-stretch" && i + 1 < argc)
-			peerStretch = atoi(argv[++i]);
-		else if (arg == "--peerset" && i + 1 < argc)
+		catch (...)
 		{
-			string peerset = argv[++i];
-			if (peerset.empty())
-			{
-				cerr << "--peerset argument must not be empty";
-				return -1;
-			}
-
-			vector<string> each;
-			boost::split(each, peerset, boost::is_any_of("\t "));
-			for (auto const& p: each)
-			{
-				string type;
-				string pubk;
-				string hostIP;
-				unsigned short port = c_defaultListenPort;
-
-				// type:key@ip[:port]
-				vector<string> typeAndKeyAtHostAndPort;
-				boost::split(typeAndKeyAtHostAndPort, p, boost::is_any_of(":"));
-				if (typeAndKeyAtHostAndPort.size() < 2 || typeAndKeyAtHostAndPort.size() > 3)
-					continue;
-
-				type = typeAndKeyAtHostAndPort[0];
-				if (typeAndKeyAtHostAndPort.size() == 3)
-					port = (uint16_t)atoi(typeAndKeyAtHostAndPort[2].c_str());
-
-				vector<string> keyAndHost;
-				boost::split(keyAndHost, typeAndKeyAtHostAndPort[1], boost::is_any_of("@"));
-				if (keyAndHost.size() != 2)
-					continue;
-				pubk = keyAndHost[0];
-				if (pubk.size() != 128)
-					continue;
-				hostIP = keyAndHost[1];
-
-				// todo: use Network::resolveHost()
-				if (hostIP.size() < 4 /* g.it */)
-					continue;
-
-				bool required = type == "required";
-				if (!required && type != "default")
-					continue;
-
-				Public publicKey(fromHex(pubk));
-				try
-				{
-					preferredNodes[publicKey] = make_pair(NodeIPEndpoint(bi::address::from_string(hostIP), port, port), required);
-				}
-				catch (...)
-				{
-					cerr << "Unrecognized peerset: " << peerset << "\n";
-					return -1;
-				}
-			}
+			cerr << "Bad --bid option: " << vm["bid"].as<string>() << "\n";
+			return -1;
 		}
-		else if ((arg == "-o" || arg == "--mode") && i + 1 < argc)
+	}
+	if (vm.count("listen-ip"))
+	{
+		listenIP = vm["listen-ip"].as<string>();
+		listenSet = true;
+	}
+	if (vm.count("listen")) {
+		listenPort = vm["listen"].as<short>();
+		listenSet = true;
+	}
+	if (vm.count("listen-port")) {
+		listenPort = vm["listen-port"].as<short>();
+		listenSet = true;
+	}
+	if (vm.count("public-ip")) {
+		publicIP = vm["public-ip"].as<string>();
+	}
+	if (vm.count("public")) {
+		publicIP = vm["public"].as<string>();
+	}
+	if (vm.count("remote"))
+	{
+		string host = vm["remote"].as<string>();
+		string::size_type found = host.find_first_of(':');
+		if (found != std::string::npos)
 		{
-			string m = argv[++i];
-			if (m == "full")
-				nodeMode = NodeMode::Full;
-			else if (m == "peer")
-				nodeMode = NodeMode::PeerServer;
-			else
-			{
-				cerr << "Unknown mode: " << m << "\n";
-				return -1;
-			}
+			remoteHost = host.substr(0, found);
+			remotePort = (short)atoi(host.substr(found + 1, host.length()).c_str());
 		}
-#if ETH_EVMJIT
-		else if (arg == "--vm" && i + 1 < argc)
+		else
+			remoteHost = host;
+	}
+	if (vm.count("port"))
+	{
+		remotePort = vm["port"].as<short>();
+	}
+	if (vm.count("password"))
+		passwordsToNote.push_back(vm["password"].as<string>());
+	if (vm.count("master"))
+	{
+		masterPassword = vm["master"].as<string>();
+		masterSet = true;
+	}
+	if (vm.count("dont-check"))
+		safeImport = true;
+	if (vm.count("script"))
+		scripts.push_back(vm["script"].as<string>());
+	if (vm.count("format"))
+	{
+		string m = vm["format"].as<string>();
+		if (m == "binary")
+			exportFormat = Format::Binary;
+		else if (m == "hex")
+			exportFormat = Format::Hex;
+		else if (m == "human")
+			exportFormat = Format::Human;
+		else
 		{
-			string vmKind = argv[++i];
-			if (vmKind == "interpreter")
-				VMFactory::setKind(VMKind::Interpreter);
-			else if (vmKind == "jit")
-				VMFactory::setKind(VMKind::JIT);
-			else if (vmKind == "smart")
-				VMFactory::setKind(VMKind::Smart);
-			else
-			{
-				cerr << "Unknown VM kind: " << vmKind << "\n";
-				return -1;
-			}
+			cerr << "Bad " << "--format" << " option: " << m << "\n";
+			return -1;
 		}
-#endif
-		else if (arg == "--shh")
-			useWhisper = true;
-		else if (arg == "-h" || arg == "--help")
-			help();
-		else if (arg == "-V" || arg == "--version")
-			version();
-		else if (arg == "--test")
+	}
+	if (vm.count("to"))
+		exportTo = vm["to"].as<string>();
+	if (vm.count("from"))
+		exportFrom = vm["from"].as<string>();
+	if (vm.count("only"))
+		exportTo = exportFrom = vm["only"].as<string>();
+	if (vm.count("upnp"))
+	{
+		string m = vm["upnp"].as<string>();
+		if (isTrue(m))
+			upnp = true;
+		else if (isFalse(m))
+			upnp = false;
+		else
 		{
-			testingMode = true;
-			enableDiscovery = false;
-			disableDiscovery = true;
-			noPinning = true;
-			bootstrap = false;
+			cerr << "Bad " << "--upnp" << " option: " << m << "\n";
+			return -1;
+		}
+	}
+	if (vm.count("network-id"))
+		try {
+			networkID = stol(vm["network-id"].as<string>());
 		}
-		else if ((arg == std::string("--import-snapshot")) && i + 1 < argc)
+		catch (...)
 		{
-			mode = OperationMode::ImportSnapshot;
-			filename = argv[++i];
+			cerr << "Bad " << "--network-id" << " option: " << vm["network-id"].as<string>() << "\n";
+			return -1;
 		}
-		else
+	if (vm.count("private"))
+		try {
+			privateChain = vm["private"].as<string>();
+		}
+		catch (...)
 		{
-			cerr << "Invalid argument: " << arg << "\n";
-			exit(-1);
+			cerr << "Bad " << "--private" << " option: " << vm["private"].as<string>() << "\n";
+			return -1;
 		}
+	if (vm.count("independent"))
+		try {
+			privateChain = vm["independent"].as<string>();
+			noPinning = enableDiscovery = true;
+		}
+		catch (...)
+		{
+			cerr << "Bad " << "--independent" << " option: " << vm["independent"].as<string>() << "\n";
+			return -1;
+		}
+	if (vm.count("kill") || vm.count("kill-blockchain"))
+		withExisting = WithExisting::Kill;
+	if (vm.count("rebuild"))
+		withExisting = WithExisting::Verify;
+	if (vm.count("rescue"))
+		withExisting = WithExisting::Rescue;
+	if (vm.count("client-name"))
+		clientName = vm["client-name"].as<string>();
+	if (vm.count("address"))
+		try {
+			author = h160(fromHex(vm["address"].as<string>(), WhenError::Throw));
+		}
+		catch (BadHexCharacter&)
+		{
+			cerr << "Bad hex in " << "--adress" << " option: " << vm["address"].as<string>() << "\n";
+			return -1;
+		}
+		catch (...)
+		{
+			cerr << "Bad " << "--adress" << " option: " << vm["address"].as<string>() << "\n";
+			return -1;
+		}
+	if (vm.count("author"))
+		try {
+			author = h160(fromHex(vm["author"].as<string>(), WhenError::Throw));
+		}
+		catch (BadHexCharacter&)
+		{
+			cerr << "Bad hex in " << "--author" << " option: " << vm["author"].as<string>() << "\n";
+			return -1;
+		}
+		catch (...)
+		{
+			cerr << "Bad " << "--author" << " option: " << vm["author"].as<string>() << "\n";
+			return -1;
+		}
+	if ((vm.count("import-secret")))
+	{
+		Secret s(fromHex(vm["import-secret"].as<string>()));
+		toImport.emplace_back(s);
+	}
+	if (vm.count("import-session-secret"))
+	{
+		Secret s(fromHex(vm["import-session-secret"].as<string>()));
+		toImport.emplace_back(s);
+	}
+	if (vm.count("help")) {
+		cout << "\n\n\n\n\n";
+		cout
+				<< "Usage eth [OPTIONS]\n"
+				<< "Options:\n\n"
+				<< "Wallet usage:\n";
+		AccountManager::streamAccountHelp(cout);
+		AccountManager::streamWalletHelp(cout);
+		cout << clientDefaultMode;
+		cout << "  --json-rpc-port            <n>  Specify JSON-RPC server port \n                              (implies '-j', default: " << SensibleHttpPort << ").\n";
+		cout << clientTransacting;
+		cout << "  --ask                  <wei>  Set the minimum ask gas price under which no transaction will be mined\n                         (default" << toString(DefaultGasPrice) << ").\n";
+		cout << "  --bid                  <wei>  Set the bid gas price to pay for transactions\n                         (default " << toString(DefaultGasPrice) << ").\n";
+		cout << clientMining << clientNetworking;
+		MinerCLI::streamHelp(cout);
+		cout << importExportMode << generalOptions << "  -d[--db-path,--path,--datadir] <path>  Load database from path\n                          (default: " << getDataDir() << ").\n";
+		cout << experimentalProofOfConcept;
+		exit(0);
 	}
-
 	if (!configJSON.empty())
 	{
 		try
diff --git a/ethkey/CMakeLists.txt b/ethkey/CMakeLists.txt
index 43629dd2a7a..c65a7ed8fab 100644
--- a/ethkey/CMakeLists.txt
+++ b/ethkey/CMakeLists.txt
@@ -1,2 +1,2 @@
 add_executable(ethkey KeyAux.h main.cpp)
-target_link_libraries(ethkey PRIVATE ethcore devcore)
+target_link_libraries(ethkey PRIVATE ethcore devcore Boost::program_options)
diff --git a/ethkey/main.cpp b/ethkey/main.cpp
index e6353e30424..99071f53e3f 100644
--- a/ethkey/main.cpp
+++ b/ethkey/main.cpp
@@ -26,12 +26,16 @@
 #include <libdevcore/FileSystem.h>
 #include <libdevcore/Log.h>
 #include <libethcore/KeyManager.h>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 #include "BuildInfo.h"
 #include "KeyAux.h"
 using namespace std;
 using namespace dev;
 using namespace dev::eth;
 
+namespace po = boost::program_options;
+
 void help()
 {
 	cout
@@ -82,23 +86,48 @@ int main(int argc, char** argv)
 	setDefaultOrCLocale();
 	KeyCLI m(KeyCLI::OperationMode::ListBare);
 	g_logVerbosity = 0;
-
+	po::options_description generalOptions("General Options");
+	generalOptions.add_options()
+		("verbosity,v", po::value<string>(), "<0 - 9>  Set the log verbosity from 0 to 9 (default: 8).")
+		("version,V", "Show the version and exit.")
+		("help,h",  "Show this help message and exit.")
+	;
+	int ac = 1;
 	for (int i = 1; i < argc; ++i)
 	{
 		string arg = argv[i];
 		if (m.interpretOption(i, argc, argv)) {}
-		else if ((arg == "-v" || arg == "--verbosity") && i + 1 < argc)
-			g_logVerbosity = atoi(argv[++i]);
-		else if (arg == "-h" || arg == "--help")
-			help();
-		else if (arg == "-V" || arg == "--version")
-			version();
+		else if (((arg == "-v" || arg == "--verbosity") && i + 1 < argc) || arg == "-h" || arg == "--help" || arg == "-V" || arg == "--version") {
+			argv[ac] = argv[i];
+			ac++;
+			if (arg == "-v" || arg == "--verbosity") {
+				i++;
+				argv[ac] = argv[i];
+				ac++;
+			}
+			continue;
+		}
 		else
 		{
 			cerr << "Invalid argument: " << arg << endl;
 			exit(-1);
 		}
 	}
+	po::variables_map vm;
+	po::store(po::parse_command_line(ac, argv, generalOptions), vm);
+	po::notify(vm);
+	if (vm.count("help")) {
+		cout
+				<< "Usage ethkey [OPTIONS]" << endl
+				<< "Options:" << endl << endl;
+		KeyCLI::streamHelp(cout);
+		cout << generalOptions;
+		exit(0);
+	}
+	if (vm.count("version"))
+		version();
+	if (vm.count("verbosity"))
+		g_logVerbosity = atoi(vm["verbosity"].as<string>().c_str());
 
 	m.execute();
 
diff --git a/ethvm/CMakeLists.txt b/ethvm/CMakeLists.txt
index f1c5518538f..7405636ee3d 100644
--- a/ethvm/CMakeLists.txt
+++ b/ethvm/CMakeLists.txt
@@ -1,5 +1,5 @@
 add_executable(ethvm main.cpp)
 
-target_link_libraries(ethvm PRIVATE ethereum evm ethashseal devcore)
+target_link_libraries(ethvm PRIVATE ethereum evm ethashseal devcore Boost::program_options)
 
 install(TARGETS ethvm DESTINATION bin OPTIONAL)
diff --git a/ethvm/main.cpp b/ethvm/main.cpp
index f401e4cc7e4..743c7fe521e 100755
--- a/ethvm/main.cpp
+++ b/ethvm/main.cpp
@@ -32,13 +32,15 @@
 #include <libevm/VM.h>
 #include <libevm/VMFactory.h>
 #include <boost/algorithm/string.hpp>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 #include <fstream>
 #include <iostream>
 #include <ctime>
 using namespace std;
 using namespace dev;
 using namespace eth;
-
+namespace po = boost::program_options;
 namespace
 {
 int64_t maxBlockGasLimit()
@@ -47,34 +49,6 @@ int64_t maxBlockGasLimit()
 	return limit;
 }
 
-void help()
-{
-	cout
-		<< "Usage ethvm <options> [trace|stats|output|test] (<file>|-)\n"
-		<< "Transaction options:\n"
-		<< "    --value <n>  Transaction should transfer the <n> wei (default: 0).\n"
-		<< "    --gas <n>    Transaction should be given <n> gas (default: block gas limit).\n"
-		<< "    --gas-limit <n>  Block gas limit (default: " << maxBlockGasLimit() << ").\n"
-		<< "    --gas-price <n>  Transaction's gas price' should be <n> (default: 0).\n"
-		<< "    --sender <a>  Transaction sender should be <a> (default: 0000...0069).\n"
-		<< "    --origin <a>  Transaction origin should be <a> (default: 0000...0069).\n"
-		<< "    --input <d>   Transaction code should be <d>\n"
-		<< "    --code <d>    Contract code <d>. Makes transaction a call to this contract\n"
-#if ETH_EVMJIT
-		<< "\nVM options:\n"
-		<< "    --vm <vm-kind>  Select VM. Options are: interpreter, jit, smart. (default: interpreter)\n"
-#endif // ETH_EVMJIT
-		<< "Network options:\n"
-		<< "    --network Main|Ropsten|Homestead|Frontier|Byzantium|Constantinople\n\n"
-		<< "Options for trace:\n"
-		<< "    --flat  Minimal whitespace in the JSON.\n"
-		<< "    --mnemonics  Show instruction mnemonics in the trace (non-standard).\n\n"
-		<< "General options:\n"
-		<< "    -V,--version  Show the version and exit.\n"
-		<< "    -h,--help  Show this help message and exit.\n";
-	exit(0);
-}
-
 void version()
 {
 	cout << "ethvm version " << dev::Version << "\n";
@@ -149,75 +123,67 @@ int main(int argc, char** argv)
 
 	Ethash::init();
 	NoProof::init();
-
-	for (int i = 1; i < argc; ++i)
-	{
+	po::options_description transactionOptions("Transaction options");
+	transactionOptions.add_options()
+			("value", po::value<string>(), "<n>  Transaction should transfer the <n> wei (default: 0).")
+			("gas", po::value<string>(), "<n>    Transaction should be given <n> gas (default: block gas limit).")
+			("gas-price", po::value<string>(), "<n>  Transaction's gas price' should be <n> (default: 0).")
+			("sender", po::value<string>(), "<a>  Transaction sender should be <a> (default: 0000...0069).")
+			("origin", po::value<string>(), "<a>  Transaction origin should be <a> (default: 0000...0069).")
+			("input", po::value<string>(), "<d>   Transaction code should be <d>")
+			("code", po::value<string>(), "<d>    Contract code <d>. Makes transaction a call to this contract")
+			("gas-limit", po::value<string>(), "")
+	;
+	po::options_description vmOptions("VM options");
+	//#if ETH_EVMJIT
+	vmOptions.add_options()
+			("vm", "<vm-kind>  Select VM. Options are: interpreter, jit, smart. (default: interpreter)")
+	;
+	//#endif // ETH_EVMJIT
+	po::options_description networkOptions("Network options");
+	networkOptions.add_options()
+			("network",  po::value<string>(), "Main|Ropsten|Homestead|Frontier|Byzantium|Constantinople\n");
+	;
+	po::options_description optionsForTrace("Options for trace");
+	optionsForTrace.add_options()
+			("flat", "Minimal whitespace in the JSON.")
+			("mnemonics", "Show instruction mnemonics in the trace (non-standard).\n")
+	;
+	po::options_description generalOptions("General options");
+	generalOptions.add_options()
+			("version,v", "Show the version and exit.")
+			("help,h", "Show this help message and exit.")
+			("author", po::value<string>(), "<a> Set author")
+			("difficulty", po::value<string>(), "<d> Set difficulty")
+			("number", po::value<string>(), "<d> Set number")
+			("timestamp", po::value<string>(), "<d> Set timestamp")
+	;
+	po::options_description allowedOptions("Usage ethvm <options> [trace|stats|output|test] (<file>|-)");
+	allowedOptions.add(vmOptions).add(networkOptions).add(optionsForTrace).add(generalOptions).add(transactionOptions);
+	po::variables_map vm;
+	int ac = 1;
+	for (int i = 1; i < argc; ++i) {
 		string arg = argv[i];
-		if (arg == "-h" || arg == "--help")
-			help();
-		else if (arg == "-V" || arg == "--version")
-			version();
-		else if (arg == "--vm" && i + 1 < argc)
-		{
-			string vmKindStr = argv[++i];
-			if (vmKindStr == "interpreter")
-				vmKind = VMKind::Interpreter;
-#if ETH_EVMJIT
-			else if (vmKindStr == "jit")
-				vmKind = VMKind::JIT;
-			else if (vmKindStr == "smart")
-				vmKind = VMKind::Smart;
-#endif
-			else
-			{
-				cerr << "Unknown/unsupported VM kind: " << vmKindStr << "\n";
-				return -1;
-			}
-		}
-		else if (arg == "--mnemonics")
-			st.setShowMnemonics();
-		else if (arg == "--flat")
-			styledJson = false;
-		else if (arg == "--sender" && i + 1 < argc)
-			sender = Address(argv[++i]);
-		else if (arg == "--origin" && i + 1 < argc)
-			origin = Address(argv[++i]);
-		else if (arg == "--gas" && i + 1 < argc)
-			gas = u256(argv[++i]);
-		else if (arg == "--gas-price" && i + 1 < argc)
-			gasPrice = u256(argv[++i]);
-		else if (arg == "--author" && i + 1 < argc)
-			blockHeader.setAuthor(Address(argv[++i]));
-		else if (arg == "--number" && i + 1 < argc)
-			blockHeader.setNumber(u256(argv[++i]));
-		else if (arg == "--difficulty" && i + 1 < argc)
-			blockHeader.setDifficulty(u256(argv[++i]));
-		else if (arg == "--timestamp" && i + 1 < argc)
-			blockHeader.setTimestamp(u256(argv[++i]));
-		else if (arg == "--gas-limit" && i + 1 < argc)
-			blockHeader.setGasLimit(u256(argv[++i]).convert_to<int64_t>());
-		else if (arg == "--value" && i + 1 < argc)
-			value = u256(argv[++i]);
-		else if (arg == "--network" && i + 1 < argc)
-		{
-			string network = argv[++i];
-			if (network == "Constantinople")
-				networkName = Network::ConstantinopleTest;
-			else if (network == "Byzantium")
-				networkName = Network::ByzantiumTest;
-			else if (network == "Frontier")
-				networkName = Network::FrontierTest;
-			else if (network == "Ropsten")
-				networkName = Network::Ropsten;
-			else if (network == "Homestead")
-				networkName = Network::HomesteadTest;
-			else if (network == "Main")
-				networkName = Network::MainNetwork;
-			else
-			{
-				cerr << "Unknown network type: " << network << "\n";
-				return -1;
+		if ((i + 1 < argc && (arg == "--vm" || arg == "--sender" ||
+		                      arg == "--origin" || arg == "--gas" || arg == "--gas-price" || arg == "--author" ||
+		                      arg == "--number" ||
+		                      arg == "--difficulty" || arg == "--timestamp" || arg == "--gas-limit" ||
+		                      arg == "--value" || arg == "--network" ||
+		                      arg == "--input" || arg == "--code")) || arg == "--mnemonics" || arg == "--flat" ||
+		                      arg == "-h" || arg == "--help" || arg == "--version" || arg == "-V") {
+			argv[ac] = argv[i];
+			ac++;
+			if (arg == "--vm" || arg == "--sender" ||
+			    arg == "--origin" || arg == "--gas" || arg == "--gas-price" || arg == "--author" ||
+			    arg == "--number" ||
+			    arg == "--difficulty" || arg == "--timestamp" || arg == "--gas-limit" ||
+			    arg == "--value" || arg == "--network" ||
+			    arg == "--input" || arg == "--code") {
+				i++;
+				argv[ac] = argv[i];
+				ac++;
 			}
+			continue;
 		}
 		else if (arg == "stats")
 			mode = Mode::Statistics;
@@ -227,10 +193,6 @@ int main(int argc, char** argv)
 			mode = Mode::Trace;
 		else if (arg == "test")
 			mode = Mode::Test;
-		else if (arg == "--input" && i + 1 < argc)
-			data = fromHex(argv[++i]);
-		else if (arg == "--code" && i + 1 < argc)
-			code = fromHex(argv[++i]);
 		else if (inputFile.empty())
 			inputFile = arg;  // Assign input file name only once.
 		else
@@ -239,6 +201,82 @@ int main(int argc, char** argv)
 			return -1;
 		}
 	}
+	po::store(po::parse_command_line(ac, argv, allowedOptions), vm);
+	po::notify(vm);
+	if (vm.count("help")) {
+		cout << allowedOptions;
+		cout << "                         <n>  Block gas limit (default: " << maxBlockGasLimit() << ").";
+		exit(0);
+	}
+	if (vm.count("version")) {
+		version();
+	}
+	if (vm.count("vm")) {
+		string vmKindStr = vm["vm"].as<string>();
+		if (vmKindStr == "interpreter")
+			vmKind = VMKind::Interpreter;
+#if ETH_EVMJIT
+			else if (vmKindStr == "jit")
+				vmKind = VMKind::JIT;
+			else if (vmKindStr == "smart")
+				vmKind = VMKind::Smart;
+#endif
+		else
+		{
+			cerr << "Unknown/unsupported VM kind: " << vmKindStr << "\n";
+			return -1;
+		}
+	}
+	if (vm.count("mnemonics"))
+		st.setShowMnemonics();
+	if (vm.count("flat"))
+		styledJson = false;
+	if (vm.count("sender"))
+		sender = Address(vm["sender"].as<string>());
+	if (vm.count("origin"))
+		origin = Address(vm["origin"].as<string>());
+	if (vm.count("gas"))
+		gas = u256(vm["gas"].as<string>());
+	if (vm.count("gas-price"))
+		gasPrice = u256(vm["gas-price"].as<string>());
+	if (vm.count("author"))
+		blockHeader.setAuthor(Address(vm["author"].as<string>()));
+	if (vm.count("number"))
+		blockHeader.setNumber(u256(vm["number"].as<string>()));
+	if (vm.count("difficulty"))
+		blockHeader.setDifficulty(u256(vm["difficulty"].as<string>()));
+	if (vm.count("timestamp"))
+		blockHeader.setTimestamp(u256(vm["timestamp"].as<string>()));
+	if (vm.count("gas-limit"))
+		blockHeader.setGasLimit(u256(vm["gas-limit"].as<string>()).convert_to<int64_t>());
+	if (vm.count("value"))
+		value = u256(vm["value"].as<string>());
+	if (vm.count("network"))
+	{
+		string network = vm["network"].as<string>();
+		if (network == "Constantinople")
+			networkName = Network::ConstantinopleTest;
+		else if (network == "Byzantium")
+			networkName = Network::ByzantiumTest;
+		else if (network == "Frontier")
+			networkName = Network::FrontierTest;
+		else if (network == "Ropsten")
+			networkName = Network::Ropsten;
+		else if (network == "Homestead")
+			networkName = Network::HomesteadTest;
+		else if (network == "Main")
+			networkName = Network::MainNetwork;
+		else
+		{
+			cerr << "Unknown network type: " << network << "\n";
+			return -1;
+		}
+	}
+	if (vm.count("input"))
+		data = fromHex(vm["input"].as<string>());
+	if (vm.count("code"))
+		code = fromHex(vm["code"].as<string>());
+
 
 	VMFactory::setKind(vmKind);
 
diff --git a/rlp/CMakeLists.txt b/rlp/CMakeLists.txt
index 184f77ff834..0a26589f159 100644
--- a/rlp/CMakeLists.txt
+++ b/rlp/CMakeLists.txt
@@ -1,3 +1,3 @@
 add_executable(rlp main.cpp)
 target_include_directories(rlp PRIVATE ../utils)
-target_link_libraries(rlp PRIVATE devcrypto devcore)
+target_link_libraries(rlp PRIVATE devcrypto devcore Boost::program_options)
diff --git a/rlp/main.cpp b/rlp/main.cpp
index 68499f9fefc..4d6ed45f35f 100644
--- a/rlp/main.cpp
+++ b/rlp/main.cpp
@@ -24,6 +24,8 @@
 #include <iostream>
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 #include <json_spirit/JsonSpiritHeaders.h>
 #include <libdevcore/CommonIO.h>
 #include <libdevcore/RLP.h>
@@ -34,39 +36,7 @@
 using namespace std;
 using namespace dev;
 namespace js = json_spirit;
-
-void help()
-{
-	cout
-		<< "Usage rlp <mode> [OPTIONS]" << endl
-		<< "Modes:" << endl
-		<< "    create <json>  Given a simplified JSON string, output the RLP." << endl
-		<< "    render [ <file> | -- ]  Render the given RLP. Options:" << endl
-		<< "      --indent <string>  Use string as the level indentation (default '  ')." << endl
-		<< "      --hex-ints  Render integers in hex." << endl
-		<< "      --string-ints  Render integers in the same way as strings." << endl
-		<< "      --ascii-strings  Render data as C-style strings or hex depending on content being ASCII." << endl
-		<< "      --force-string  Force all data to be rendered as C-style strings." << endl
-		<< "      --force-escape  When rendering as C-style strings, force all characters to be escaped." << endl
-		<< "      --force-hex  Force all data to be rendered as raw hex." << endl
-		<< "    list [ <file> | -- ]  List the items in the RLP list by hash and size." << endl
-		<< "    extract [ <file> | -- ]  Extract all items in the RLP list, named by hash." << endl
-		<< "    assemble [ <manifest> | <base path> ] <file> ...  Given a manifest & files, output the RLP." << endl
-		<< "      -D,--dapp  Dapp-building mode; equivalent to --encrypt --64." << endl
-		<< endl
-		<< "General options:" << endl
-		<< "    -e,--encrypt  Encrypt the RLP data prior to output." << endl
-		<< "    -L,--lenience  Try not to bomb out early if possible." << endl
-		<< "    -x,--hex,--base-16  Treat input RLP as hex encoded data." << endl
-		<< "    -k,--keccak  Output Keccak-256 hash only." << endl
-		<< "    --64,--base-64  Treat input RLP as base-64 encoded data." << endl
-		<< "    -b,--bin,--base-256  Treat input RLP as raw binary data." << endl
-		<< "    -q,--quiet  Don't place additional information on stderr." << endl
-		<< "    -h,--help  Print this help message and exit." << endl
-		<< "    -V,--version  Show the version and exit." << endl
-		;
-	exit(0);
-}
+namespace po = boost::program_options;
 
 void version()
 {
@@ -215,61 +185,136 @@ int main(int argc, char** argv)
 	bool quiet = false;
 	bool encrypt = false;
 	RLPStreamer::Prefs prefs;
-
+	po::options_description modesOptions("Modes");
+	modesOptions.add_options()
+			("indent,i", po::value<string> (), "<string>  Use string as the level indentation (default '  ').")
+			("hex-ints", "Render integers in hex.")
+			("string-ints", "Render integers in the same way as strings.")
+			("ascii-strings", "Render data as C-style strings or hex depending on content being ASCII.")
+			("force-string", "Force all data to be rendered as C-style strings.")
+			("force-escape", "When rendering as C-style strings, force all characters to be escaped.")
+			("force-hex", "Force all data to be rendered as raw hex.")
+			("dapp,D", "Dapp-building mode; equivalent to --encrypt --64.")
+	;
+	po::options_description generalOptions("General options");
+	generalOptions.add_options()
+			("encrypt,e", "Encrypt the RLP data prior to output.")
+			("lenience,L", "Try not to bomb out early if possible.")
+			("hex,x", "Treat input RLP as hex encoded data.")
+			("base-16", "Treat input RLP as hex encoded data.")
+			("keccak,k", "Output Keccak-256 hash only.")
+			("base-64", "Treat input RLP as base-64 encoded data.")
+			("64", "Treat input RLP as base-64 encoded data.")
+			("bin,b", "Treat input RLP as raw binary data.")
+			("base-256", "Treat input RLP as raw binary data.")
+			("quiet,q", "Don't place additional information on stderr.")
+			("help,h", "Print this help message and exit.")
+			("version,V", "Show the version and exit.")
+	;
+	po::options_description allowedOptions("Allowed options");
+	allowedOptions.add(generalOptions).add(modesOptions);
+	int ac = 1;
 	for (int i = 1; i < argc; ++i)
 	{
+
 		string arg = argv[i];
-		if (arg == "-h" || arg == "--help")
-			help();
+		if ((arg == "-i" || arg == "--indent") && i + 1 < argc) {
+			argv[ac] = argv[i];
+			ac++;
+			i++;
+			argv[ac] = argv[i];
+			ac++;
+			continue;
+		}
+		else if (arg == "-h" || arg == "--help" || arg == "--hex-ints" || arg == "--ascii-strings" || arg == "-L" || arg == "--lenience" ||
+			arg	== "--force-string" || arg == "--force-hex" || arg == "--force-escape" || arg == "-n" || arg == "--nice" ||
+			arg == "-D" || arg == "--dapp" || arg == "-V" || arg == "--version" || arg == "-q" || arg == "--quiet" || arg == "-x" ||
+			arg == "--hex" || arg == "--base-16" || arg == "-k" || arg == "--keccak" || arg == "--64" || arg == "--base-64" ||
+			arg == "-b" || arg == "--bin" || arg == "--base-256" || arg == "-e" || arg == "--encrypt") {
+			argv[ac] = argv[i];
+			ac++;
+			continue;
+		}
 		else if (arg == "render")
 			mode = Mode::Render;
 		else if (arg == "create")
 			mode = Mode::Create;
-		else if ((arg == "-i" || arg == "--indent") && i + 1 < argc)
-			prefs.indent = argv[++i];
-		else if (arg == "--hex-ints")
-			prefs.hexInts = true;
-		else if (arg == "--string-ints")
-			prefs.stringInts = true;
-		else if (arg == "--ascii-strings")
-			prefs.forceString = prefs.forceHex = false;
-		else if (arg == "--force-string")
-			prefs.forceString = true;
-		else if (arg == "--force-hex")
-			prefs.forceHex = true, prefs.forceString = false;
-		else if (arg == "--force-escape")
-			prefs.escapeAll = true;
-		else if (arg == "-n" || arg == "--nice")
-			prefs.forceString = true, prefs.stringInts = false, prefs.forceHex = false, prefs.indent = "  ";
 		else if (arg == "list")
 			mode = Mode::ListArchive;
 		else if (arg == "extract")
 			mode = Mode::ExtractArchive;
 		else if (arg == "assemble")
 			mode = Mode::AssembleArchive;
-		else if (arg == "-L" || arg == "--lenience")
-			lenience = true;
-		else if (arg == "-D" || arg == "--dapp")
-			encrypt = true, encoding = Encoding::Base64;
-		else if (arg == "-V" || arg == "--version")
-			version();
-		else if (arg == "-q" || arg == "--quiet")
-			quiet = true;
-		else if (arg == "-x" || arg == "--hex" || arg == "--base-16")
-			encoding = Encoding::Hex;
-		else if (arg == "-k" || arg == "--keccak")
-			encoding = Encoding::Keccak;
-		else if (arg == "--64" || arg == "--base-64")
-			encoding = Encoding::Base64;
-		else if (arg == "-b" || arg == "--bin" || arg == "--base-256")
-			encoding = Encoding::Binary;
-		else if (arg == "-e" || arg == "--encrypt")
-			encrypt = true;
 		else if (inputFile.empty())
 			inputFile = arg;
 		else
 			otherInputs.push_back(arg);
 	}
+	po::variables_map vm;
+	po::store(po::parse_command_line(ac, argv, allowedOptions), vm);
+	po::notify(vm);
+	if (vm.count("help")) {
+		cout << "Usage rlp <mode> [OPTIONS]" << endl << modesOptions
+			 << "    create <json>  Given a simplified JSON string, output the RLP." << endl
+			 << "    render [ <file> | -- ]  Render the given RLP. Options:" << endl
+			 << "    list [ <file> | -- ]  List the items in the RLP list by hash and size." << endl
+			 << "    extract [ <file> | -- ]  Extract all items in the RLP list, named by hash." << endl
+			 << "    assemble [ <manifest> | <base path> ] <file> ...  Given a manifest & files, output the RLP." << endl
+			 << generalOptions;
+		exit(0);
+	}
+	if (vm.count("lenience"))
+		lenience = true;
+	if (vm.count("dapp"))
+		encrypt = true, encoding = Encoding::Base64;
+	if (vm.count("version"))
+		version();
+	if (vm.count("quiet"))
+		quiet = true;
+	if (vm.count("hex") || vm.count("base-16"))
+		encoding = Encoding::Hex;
+	if (vm.count("keccak"))
+		encoding = Encoding::Keccak;
+	if (vm.count("64") || vm.count("base-64"))
+		encoding = Encoding::Base64;
+	if (vm.count("bin") || vm.count("base-256"))
+		encoding = Encoding::Binary;
+	if (vm.count("encrypt"))
+		encrypt = true;
+	if (vm.count("indent"))
+		prefs.indent = vm["indent"].as<string>();
+	if (vm.count("hex-ints"))
+		prefs.hexInts = true;
+	if (vm.count("string-ints"))
+		prefs.stringInts = true;
+	if (vm.count("ascii-strings"))
+		prefs.forceString = prefs.forceHex = false;
+	if (vm.count("force-string"))
+		prefs.forceString = true;
+	if (vm.count("force-hex"))
+		prefs.forceHex = true, prefs.forceString = false;
+	if (vm.count("force-escape"))
+		prefs.escapeAll = true;
+	if (vm.count("nice"))
+		prefs.forceString = true, prefs.stringInts = false, prefs.forceHex = false, prefs.indent = "  ";
+	if (vm.count("lenience"))
+		lenience = true;
+	if (vm.count("dapp"))
+		encrypt = true, encoding = Encoding::Base64;
+	if (vm.count("version"))
+		version();
+	if (vm.count("quiet"))
+		quiet = true;
+	if (vm.count("hex") || vm.count("base-16"))
+		encoding = Encoding::Hex;
+	if (vm.count("keccak"))
+		encoding = Encoding::Keccak;
+	if (vm.count("64") || vm.count("base-64"))
+		encoding = Encoding::Base64;
+	if (vm.count("bin") || vm.count("base-256"))
+		encoding = Encoding::Binary;
+	if (vm.count("encrypt"))
+		encrypt = true;
 
 	bytes in;
 	if (inputFile == "--")
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9d4005e1cc4..9b070976ce4 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -48,7 +48,7 @@ endforeach(file)
 
 add_executable(testeth ${sources})
 target_include_directories(testeth PRIVATE ../utils)
-target_link_libraries(testeth PRIVATE ethereum ethashseal web3jsonrpc devcrypto devcore Cryptopp)
+target_link_libraries(testeth PRIVATE ethereum ethashseal web3jsonrpc devcrypto devcore Cryptopp Boost::program_options)
 
 enable_testing()
 set(CTEST_OUTPUT_ON_FAILURE TRUE)
diff --git a/test/tools/libtesteth/Options.cpp b/test/tools/libtesteth/Options.cpp
index 6b59cc0f3b2..7fc459f60c7 100644
--- a/test/tools/libtesteth/Options.cpp
+++ b/test/tools/libtesteth/Options.cpp
@@ -22,15 +22,18 @@
 #include <libweb3jsonrpc/Debug.h>
 #include <test/tools/libtesteth/Options.h>
 #include <test/tools/fuzzTesting/fuzzHelper.h>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 
 using namespace std;
 using namespace dev::test;
 using namespace dev::eth;
+namespace po = boost::program_options;
 
 void printHelp()
 {
 	cout << "Usage: \n";
-	cout << std::left;
+	cout << std::left << "\n";
 	cout << "\nSetting test suite\n";
 	cout << setw(30) <<	"-t <TestSuite>" << setw(25) << "Execute test operations\n";
 	cout << setw(30) << "-t <TestSuite>/<TestCase>\n";
@@ -75,6 +78,37 @@ Options::Options(int argc, char** argv)
 	trGasIndex = -1;
 	trValueIndex = -1;
 	bool seenSeparator = false; // true if "--" has been seen.
+	po::options_description testSuits("Setting test suite");
+	testSuits.add_options()
+			("testpath", po::value<string>(), "<PathToTheTestRepo>")
+	;
+	po::options_description debugging("Debugging");
+	debugging.add_options()
+			("verbosity", po::value<string>(), "<level> Set logs verbosity. 0 - silent, 1 - only errors, 2 - informative, >2 - detailed")
+			("vm", po::value<string>(), "<interpreter|jit|smart> Set VM type for VMTests suite")
+			("vmtrace", "Enable VM trace for the test. (Require build with VMTRACE=1)")
+			("jsontrace", po::value<string>(), "<Options> Enable VM trace to stdout in json format. Argument is a json config: '{ \"disableStorage\" : false, \"disableMemory\" : false, \"disableStack\" : false, \"fullStorage\" : true }'")
+			("stats", po::value<string>(), "<OutFile> Output debug stats to the file")
+			("exectimelog", "Output execution time for each test suite")
+			("statediff","Trace state difference for state tests")
+	;
+	po::options_description additionalTests("Additional Tests");
+	additionalTests.add_options()
+			("all", "Enable all tests")
+	;
+	po::options_description testGeneration("Test Generation");
+	testGeneration.add_options()
+			("filltests", "Run test fillers")
+			("fillchain", "When filling the state tests, fill tests as blockchain instead")
+			("randomcode", po::value<int>(), "<MaxOpcodeNum> Generate smart random EVM code")
+			("createRandomTest", "Create random test and output it to the console")
+			("help", "Display list of command arguments")
+			("versionDisplay", "build information")
+			("jit", "")
+	;
+	po::options_description allowedOptions("");
+	allowedOptions.add(testSuits).add(testGeneration).add(debugging).add(additionalTests);
+	int ac = 1;
 	for (auto i = 0; i < argc; ++i)
 	{
 		auto arg = std::string{argv[i]};
@@ -100,59 +134,24 @@ Options::Options(int argc, char** argv)
 			printHelp();
 			exit(0);
 		}
-		else if (arg == "--version")
+		if (arg == "--version")
 		{
 			printVersion();
 			exit(0);
 		}
-		else if (arg == "--vm")
-		{
-			throwIfNoArgumentFollows();
-			string vmKind = argv[++i];
-			if (vmKind == "interpreter")
-				VMFactory::setKind(VMKind::Interpreter);
-			else if (vmKind == "jit")
-				VMFactory::setKind(VMKind::JIT);
-			else if (vmKind == "smart")
-				VMFactory::setKind(VMKind::Smart);
-			else
-				cerr << "Unknown VM kind: " << vmKind << "\n";
-		}
-		else if (arg == "--jit") // TODO: Remove deprecated option "--jit"
-			VMFactory::setKind(VMKind::JIT);
-		else if (arg == "--vmtrace")
-		{
-#if ETH_VMTRACE
-			vmtrace = true;
-			g_logVerbosity = 13;
-#else
-			cerr << "--vmtrace option requires a build with cmake -DVMTRACE=1\n";
-			exit(1);
-#endif
-		}
-		else if (arg == "--jsontrace")
-		{
-			throwIfNoArgumentFollows();
-			jsontrace = true;
-			auto arg = std::string{argv[++i]};
-			Json::Value value;
-			Json::Reader().parse(arg, value);
-			jsontraceOptions = debugOptions(value);
+		else if (arg == "--exectimelog" || arg == "--jit" || arg == "--vmtrace" ||  arg == "--filltests" || "--nonetwork" || arg == "--statediff" ||
+				arg == "--fillchain" || arg == "--all" || arg == "--createRandomTest" || arg == "--fulloutput") {
+			argv[ac] = argv[i];
+			ac++;
 		}
-		else if (arg == "--filltests")
-			filltests = true;
-		else if (arg == "--fillchain")
-			fillchain = true;
-		else if (arg == "--stats")
-		{
+		else if (arg == "--stats" || arg == "--vm" || arg == "--jsontrace" || arg == "--singlenet" ||
+				arg == "--verbosity" || arg == "--randomcode" || arg == "--testpath") {
 			throwIfNoArgumentFollows();
-			stats = true;
-			statsOutFile = argv[++i];
+			argv[ac] = argv[i];
+			ac++;
+			argv[ac] = argv[i];
+			ac++;
 		}
-		else if (arg == "--exectimelog")
-			exectimelog = true;
-		else if (arg == "--all")
-			all = true;
 		else if (arg == "--singletest")
 		{
 			throwIfNoArgumentFollows();
@@ -175,44 +174,12 @@ Options::Options(int argc, char** argv)
 			else
 				singleTestName = std::move(name1);
 		}
-		else if (arg == "--singlenet")
-		{
-			throwIfNoArgumentFollows();
-			singleTestNet = std::string{argv[++i]};
-			ImportTest::checkAllowedNetwork({singleTestNet});
-		}
-		else if (arg == "--fulloutput")
-			fulloutput = true;
-		else if (arg == "--verbosity")
-		{
-			throwIfNoArgumentFollows();
-			static std::ostringstream strCout; //static string to redirect logs to
-			std::string indentLevel = std::string{argv[++i]};
-			if (indentLevel == "0")
-			{
-				logVerbosity = Verbosity::None;
-				std::cout.rdbuf(strCout.rdbuf());
-				std::cerr.rdbuf(strCout.rdbuf());
-			}
-			else if (indentLevel == "1")
-				logVerbosity = Verbosity::NiceReport;
-			else
-				logVerbosity = Verbosity::Full;
-
-			int indentLevelInt = atoi(argv[i]);
-			if (indentLevelInt > g_logVerbosity)
-				g_logVerbosity = indentLevelInt;
-		}
-		else if (arg == "--createRandomTest")
-			createRandomTest = true;
 		else if (arg == "-t")
 		{
 			throwIfAfterSeparator();
 			throwIfNoArgumentFollows();
 			rCurrentTestSuite = std::string{argv[++i]};
 		}
-		else if (arg == "--nonetwork")
-			nonetwork = true;
 		else if (arg == "-d")
 		{
 			throwIfNoArgumentFollows();
@@ -228,34 +195,111 @@ Options::Options(int argc, char** argv)
 			throwIfNoArgumentFollows();
 			trValueIndex = atoi(argv[++i]);
 		}
-		else if (arg == "--testpath")
+		else if (seenSeparator)
 		{
-			throwIfNoArgumentFollows();
-			testpath = std::string{argv[++i]};
+			cerr << "Unknown option: " + arg << "\n";
+			exit(1);
 		}
-		else if (arg == "--statediff")
-			statediff = true;
-		else if (arg == "--randomcode")
+	}
+	po::variables_map vm;
+	po::store(po::parse_command_line(ac, argv, allowedOptions), vm);
+	po::notify(vm);
+	if (vm.count("nonetwork"))
+		nonetwork = true;
+	if (vm.count("testpath"))
+	{
+		testpath = vm["testpath"].as<string>();
+	}
+	if (vm.count("statediff"))
+		statediff = true;
+	if (vm.count("randomcode"))
+	{
+
+		int maxCodes = vm["randomcode"].as<int>();
+		if (maxCodes > 1000 || maxCodes <= 0)
 		{
-			throwIfNoArgumentFollows();
-			int maxCodes = atoi(argv[++i]);
-			if (maxCodes > 1000 || maxCodes <= 0)
-			{
-				cerr << "Argument for the option is invalid! (use range: 1...1000)\n";
-				exit(1);
-			}
-			cout << dev::test::RandomCode::generate(maxCodes) << "\n";
-			exit(0);
+			cerr << "Argument for the option is invalid! (use range: 1...1000)\n";
+			exit(1);
 		}
-		else if (arg == "--createRandomTest")
-			createRandomTest = true;
-		else if (seenSeparator)
+		cout << dev::test::RandomCode::generate(maxCodes) << "\n";
+		exit(0);
+	}
+	if (vm.count("singlenet"))
+	{
+		singleTestNet = vm["singlenet"].as<string>();
+		ImportTest::checkAllowedNetwork({singleTestNet});
+	}
+	if (vm.count("fulloutput"))
+		fulloutput = true;
+	if (vm.count("verbosity"))
+	{
+
+		static std::ostringstream strCout; //static string to redirect logs to
+		std::string indentLevel = vm["verbosity"].as<string>();
+		if (indentLevel == "0")
 		{
-			cerr << "Unknown option: " + arg << "\n";
-			exit(1);
+			logVerbosity = Verbosity::None;
+			std::cout.rdbuf(strCout.rdbuf());
+			std::cerr.rdbuf(strCout.rdbuf());
 		}
+		else if (indentLevel == "1")
+			logVerbosity = Verbosity::NiceReport;
+		else
+			logVerbosity = Verbosity::Full;
+
+		int indentLevelInt = atoi(indentLevel.c_str());
+		if (indentLevelInt > g_logVerbosity)
+			g_logVerbosity = indentLevelInt;
+	}
+	if (vm.count("createRandomTest"))
+		createRandomTest = true;
+	if (vm.count("vm"))
+	{
+		string vmKind = vm["vm"].as<string>();
+		if (vmKind == "interpreter")
+			VMFactory::setKind(VMKind::Interpreter);
+		else if (vmKind == "jit")
+			VMFactory::setKind(VMKind::JIT);
+		else if (vmKind == "smart")
+			VMFactory::setKind(VMKind::Smart);
+		else
+			cerr << "Unknown VM kind: " << vmKind << "\n";
 	}
 
+
+	if (vm.count("jit")) // TODO: Remove deprecated option "--jit"
+		VMFactory::setKind(VMKind::JIT);
+	if (vm.count("vmtrace"))
+	{
+#if ETH_VMTRACE
+		vmtrace = true;
+			g_logVerbosity = 13;
+#else
+		cerr << "--vmtrace option requires a build with cmake -DVMTRACE=1\n";
+		exit(1);
+#endif
+	}
+	if (vm.count("jsontrace"))
+	{
+		jsontrace = true;
+		auto arg = std::string{vm["jsontrace"].as<string>()};
+		Json::Value value;
+		Json::Reader().parse(arg, value);
+		jsontraceOptions = debugOptions(value);
+	}
+	if (vm.count("filltests"))
+		filltests = true;
+	if (vm.count("fillchain"))
+		fillchain = true;
+	if (vm.count("stats"))
+	{
+		stats = true;
+		statsOutFile = vm["stats"].as<string>();
+	}
+	if (vm.count("exectimelog"))
+		exectimelog = true;
+	if (vm.count("all"))
+		all = true;
 	//check restrickted options
 	if (createRandomTest)
 	{
diff --git a/test/unittests/libp2p/peer.cpp b/test/unittests/libp2p/peer.cpp
index 64c092eabe3..e7a545609ca 100644
--- a/test/unittests/libp2p/peer.cpp
+++ b/test/unittests/libp2p/peer.cpp
@@ -28,11 +28,14 @@
 #include <chrono>
 #include <thread>
 #include <boost/test/unit_test.hpp>
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
 
 using namespace std;
 using namespace dev;
 using namespace dev::test;
 using namespace dev::p2p;
+namespace po = boost::program_options;
 
 struct P2PPeerFixture: public TestOutputHelper
 {
@@ -328,22 +331,42 @@ int peerTest(int argc, char** argv)
 	short listenPort = 30304;
 	string remoteHost;
 	short remotePort = 30304;
-	
+	po::options_description generalOptions("General options");
+	generalOptions.add_options()
+			("listenPort,l", po::value<short>(), " set number of listenPort")
+			("remoteHost,r", po::value<string>(), " set string to remoteHost")
+			("remotePort,p", po::value<short>(), " set number to remotePort")
+			("remoteAlias,ra", po::value<string>(), " set remoteAlias");
+	;
+	int ac = 1;
 	for (int i = 1; i < argc; ++i)
 	{
 		string arg = argv[i];
-		if (arg == "-l" && i + 1 < argc)
-			listenPort = (short)atoi(argv[++i]);
-		else if (arg == "-r" && i + 1 < argc)
-			remoteHost = argv[++i];
-		else if (arg == "-p" && i + 1 < argc)
-			remotePort = (short)atoi(argv[++i]);
-		else if (arg == "-ra" && i + 1 < argc)
-			remoteAlias = Public(dev::fromHex(argv[++i]));
+		if ((arg == "-l" || arg == "-r" || arg == "-p" || arg == "-ra") && i + 1 < argc) {
+			argv[ac] = argv[i];
+			ac++;
+			i++;
+			argv[ac] = argv[i];
+			ac++;
+		}
 		else
 			remoteHost = argv[i];
 	}
-
+	po::variables_map vm;
+	po::store(po::parse_command_line(ac, argv, generalOptions), vm);
+	po::notify(vm);
+	if (vm.count("listenPort")) {
+		listenPort = vm["listenPort"].as<short>();
+	}
+	if (vm.count("remoteHost")) {
+		remoteHost = vm["remoteHost"].as<string>();
+	}
+	if (vm.count("remotePort")) {
+		remotePort = vm["remotePort"].as<short>();
+	}
+	if (vm.count("remoteAlias")) {
+		remoteAlias = Public(dev::fromHex(vm["remoteAlias"].as<string>()));
+	}
 	Host ph("Test", NetworkPreferences(listenPort));
 
 	if (!remoteHost.empty() && !remoteAlias)