inital commit, which is clearly not initial

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

client/cli/src/commands/generate.rs

@@ -0,0 +1,74 @@
+//! Implementation of the `generate` subcommand
+
+use bip39::Mnemonic;
+use clap::Parser;
+use itertools::Itertools;
+use sc_cli::{
+    with_crypto_scheme, KeystoreParams, OutputTypeFlag, 
+    CryptoSchemeFlag, Error,
+};
+
+use crate::params::NetworkSchemeFlag;
+use crate::commands::utils::print_from_uri;
+
+/// The `generate` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "generate", about = "Generate a random account")]
+pub struct GenerateCmd {
+    /// The number of words in the phrase to generate. One of 12 (default),
+    /// 15, 18, 21 and 24.
+	#[arg(short = 'w', long, value_name = "WORDS")]
+	words: Option<usize>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+}
+
+impl GenerateCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let words = match self.words {
+            Some(words_count) if [12, 15, 18, 21, 24].contains(&words_count) => Ok(words_count),
+            Some(_) => Err(Error::Input(
+                "Invalid number of words given for phrase: must be 12/15/18/21/24".into(),
+            )),
+            None => Ok(12),
+		}?;
+		let mnemonic = Mnemonic::generate(words)
+            .map_err(|e| Error::Input(format!("Mnemonic generation failed: {e}").into()))?;
+		let password = self.keystore_params.read_password()?;
+		let output = self.output_scheme.output_type;
+
+        let phrase = mnemonic.words().join(" ");
+
+		with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			print_from_uri(&phrase, password, self.network_scheme.network, output)
+		);
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn generate() {
+		let generate = GenerateCmd::parse_from(&["generate", "--password", "12345"]);
+		assert!(generate.run().is_ok())
+	}
+}

client/cli/src/commands/inspect_key.rs

@@ -0,0 +1,253 @@
+//! Implementation of the `inspect` subcommand
+
+use clap::Parser;
+use sp_core::crypto::{ExposeSecret, SecretString, SecretUri, Ss58Codec};
+use std::str::FromStr;
+use sc_cli::{
+    with_crypto_scheme, KeystoreParams, OutputTypeFlag, CryptoSchemeFlag, Error,
+    utils::read_uri,
+};
+use crate::params::NetworkSchemeFlag;
+use crate::commands::utils::{print_from_public, print_from_uri};
+
+/// The `inspect` command
+#[derive(Debug, Parser)]
+#[command(
+	name = "inspect",
+	about = "Gets a public key and a SS58 address from the provided Secret URI"
+)]
+pub struct InspectKeyCmd {
+	/// A Key URI to be inspected. May be a secret seed, secret URI
+	/// (with derivation paths and password), SS58, public URI or a hex encoded public key.
+	///
+	/// If it is a hex encoded public key, `--public` needs to be given as argument.
+	///
+	/// If the given value is a file, the file content will be used
+	/// as URI.
+	///
+	/// If omitted, you will be prompted for the URI.
+	uri: Option<String>,
+
+	/// Is the given `uri` a hex encoded public key?
+	#[arg(long)]
+	public: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+
+	/// Expect that `--uri` has the given public key/account-id.
+	///
+	/// If `--uri` has any derivations, the public key is checked against the base `uri`, i.e. the
+	/// `uri` without any derivation applied. However, if `uri` has a password or there is one
+	/// given by `--password`, it will be used to decrypt `uri` before comparing the public
+	/// key/account-id.
+	///
+	/// If there is no derivation in `--uri`, the public key will be checked against the public key
+	/// of `--uri` directly.
+	#[arg(long, conflicts_with = "public")]
+	pub expect_public: Option<String>,
+}
+
+impl InspectKeyCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let uri = read_uri(self.uri.as_ref())?;
+		let password = self.keystore_params.read_password()?;
+
+		if self.public {
+			with_crypto_scheme!(
+				self.crypto_scheme.scheme,
+				print_from_public(
+					&uri,
+					self.network_scheme.network,
+					self.output_scheme.output_type,
+				)
+			)?;
+		} else {
+			if let Some(ref expect_public) = self.expect_public {
+				with_crypto_scheme!(
+					self.crypto_scheme.scheme,
+					expect_public_from_phrase(expect_public, &uri, password.as_ref())
+				)?;
+			}
+
+			with_crypto_scheme!(
+				self.crypto_scheme.scheme,
+				print_from_uri(
+					&uri,
+					password,
+					self.network_scheme.network,
+					self.output_scheme.output_type,
+				)
+			);
+		}
+
+		Ok(())
+	}
+}
+
+/// Checks that `expect_public` is the public key of `suri`.
+///
+/// If `suri` has any derivations, `expect_public` is checked against the public key of the "bare"
+/// `suri`, i.e. without any derivations.
+///
+/// Returns an error if the public key does not match.
+fn expect_public_from_phrase<Pair: sp_core::Pair>(
+	expect_public: &str,
+	suri: &str,
+	password: Option<&SecretString>,
+) -> Result<(), Error> {
+	let secret_uri = SecretUri::from_str(suri).map_err(|e| format!("{:?}", e))?;
+	let expected_public = if let Some(public) = expect_public.strip_prefix("0x") {
+		let hex_public = array_bytes::hex2bytes(public)
+			.map_err(|_| format!("Invalid expected public key hex: `{}`", expect_public))?;
+		Pair::Public::try_from(&hex_public)
+			.map_err(|_| format!("Invalid expected public key: `{}`", expect_public))?
+	} else {
+		Pair::Public::from_string_with_version(expect_public)
+			.map_err(|_| format!("Invalid expected account id: `{}`", expect_public))?
+			.0
+	};
+
+	let pair = Pair::from_string_with_seed(
+		secret_uri.phrase.expose_secret().as_str(),
+		password
+			.or_else(|| secret_uri.password.as_ref())
+			.map(|p| p.expose_secret().as_str()),
+	)
+	.map_err(|_| format!("Invalid secret uri: {}", suri))?
+	.0;
+
+	if pair.public() == expected_public {
+		Ok(())
+	} else {
+		Err(format!("Expected public ({}) key does not match.", expect_public).into())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::crypto::{ByteArray, Pair};
+	use sp_runtime::traits::IdentifyAccount;
+
+	#[test]
+	fn inspect() {
+		let words =
+			"remember fiber forum demise paper uniform squirrel feel access exclude casual effort";
+		let seed = "0xad1fb77243b536b90cfe5f0d351ab1b1ac40e3890b41dc64f766ee56340cfca5";
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", words, "--password", "12345"]);
+		assert!(inspect.run().is_ok());
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", seed]);
+		assert!(inspect.run().is_ok());
+	}
+
+	#[test]
+	fn inspect_public_key() {
+		let public = "0x12e76e0ae8ce41b6516cce52b3f23a08dcb4cfeed53c6ee8f5eb9f7367341069";
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", "--public", public]);
+		assert!(inspect.run().is_ok());
+	}
+
+	#[test]
+	fn inspect_with_expected_public_key() {
+		let check_cmd = |seed, expected_public, success| {
+			let inspect = InspectKeyCmd::parse_from(&[
+				"inspect-key",
+				"--expect-public",
+				expected_public,
+				seed,
+			]);
+			let res = inspect.run();
+
+			if success {
+				assert!(res.is_ok());
+			} else {
+				assert!(res.unwrap_err().to_string().contains(&format!(
+					"Expected public ({}) key does not match.",
+					expected_public
+				)));
+			}
+		};
+
+		let seed =
+			"remember fiber forum demise paper uniform squirrel feel access exclude casual effort";
+		let invalid_public = "0x12e76e0ae8ce41b6516cce52b3f23a08dcb4cfeed53c6ee8f5eb9f7367341069";
+		let valid_public = sp_core::sr25519::Pair::from_string_with_seed(seed, None)
+			.expect("Valid")
+			.0
+			.public();
+		let valid_public_hex = array_bytes::bytes2hex("0x", valid_public.as_slice());
+		let valid_accountid = format!("{}", valid_public.into_account());
+
+		// It should fail with the invalid public key
+		check_cmd(seed, invalid_public, false);
+
+		// It should work with the valid public key & account id
+		check_cmd(seed, &valid_public_hex, true);
+		check_cmd(seed, &valid_accountid, true);
+
+		let password = "test12245";
+		let seed_with_password = format!("{}///{}", seed, password);
+		let valid_public_with_password =
+			sp_core::sr25519::Pair::from_string_with_seed(&seed_with_password, Some(password))
+				.expect("Valid")
+				.0
+				.public();
+		let valid_public_hex_with_password =
+			array_bytes::bytes2hex("0x", valid_public_with_password.as_slice());
+		let valid_accountid_with_password =
+			format!("{}", &valid_public_with_password.into_account());
+
+		// Only the public key that corresponds to the seed with password should be accepted.
+		check_cmd(&seed_with_password, &valid_public_hex, false);
+		check_cmd(&seed_with_password, &valid_accountid, false);
+
+		check_cmd(&seed_with_password, &valid_public_hex_with_password, true);
+		check_cmd(&seed_with_password, &valid_accountid_with_password, true);
+
+		let seed_with_password_and_derivation = format!("{}//test//account///{}", seed, password);
+
+		let valid_public_with_password_and_derivation =
+			sp_core::sr25519::Pair::from_string_with_seed(
+				&seed_with_password_and_derivation,
+				Some(password),
+			)
+			.expect("Valid")
+			.0
+			.public();
+		let valid_public_hex_with_password_and_derivation =
+			array_bytes::bytes2hex("0x", valid_public_with_password_and_derivation.as_slice());
+
+		// They should still be valid, because we check the base secret key.
+		check_cmd(&seed_with_password_and_derivation, &valid_public_hex_with_password, true);
+		check_cmd(&seed_with_password_and_derivation, &valid_accountid_with_password, true);
+
+		// And these should be invalid.
+		check_cmd(&seed_with_password_and_derivation, &valid_public_hex, false);
+		check_cmd(&seed_with_password_and_derivation, &valid_accountid, false);
+
+		// The public of the derived account should fail.
+		check_cmd(
+			&seed_with_password_and_derivation,
+			&valid_public_hex_with_password_and_derivation,
+			false,
+		);
+	}
+}

client/cli/src/commands/key.rs

@@ -0,0 +1,40 @@
+//! Key related CLI utilities
+
+use super::{generate::GenerateCmd, inspect_key::InspectKeyCmd};
+use sc_cli::{
+    GenerateKeyCmdCommon, InsertKeyCmd, InspectNodeKeyCmd, Error, 
+    SubstrateCli,
+};
+
+/// Key utilities for the cli.
+#[derive(Debug, clap::Subcommand)]
+pub enum KeySubcommand {
+	/// Generate a random node key, write it to a file or stdout and write the
+	/// corresponding peer-id to stderr
+	GenerateNodeKey(GenerateKeyCmdCommon),
+
+	/// Generate a Substrate-based random account
+	Generate(GenerateCmd),
+
+	/// Gets a public key and a SS58 address from the provided Secret URI
+	Inspect(InspectKeyCmd),
+
+	/// Load a node key from a file or stdin and print the corresponding peer-id
+	InspectNodeKey(InspectNodeKeyCmd),
+
+	/// Insert a key to the keystore of a node.
+	Insert(InsertKeyCmd),
+}
+
+impl KeySubcommand {
+	/// run the key subcommands
+	pub fn run<C: SubstrateCli>(&self, cli: &C) -> Result<(), Error> {
+		match self {
+			KeySubcommand::GenerateNodeKey(cmd) => cmd.run(),
+			KeySubcommand::Generate(cmd) => cmd.run(),
+			KeySubcommand::Inspect(cmd) => cmd.run(),
+			KeySubcommand::Insert(cmd) => cmd.run(cli),
+			KeySubcommand::InspectNodeKey(cmd) => cmd.run(),
+		}
+	}
+}

client/cli/src/commands/mod.rs

@@ -0,0 +1,11 @@
+mod key;
+mod generate;
+mod vanity;
+mod inspect_key;
+mod utils;
+
+pub use self::{
+    key::KeySubcommand, vanity::VanityCmd, inspect_key::InspectKeyCmd,
+    generate::GenerateCmd,
+    utils::{unwrap_or_default_ss58_name, print_from_uri, print_from_public},
+};

client/cli/src/commands/utils.rs

@@ -0,0 +1,220 @@
+use serde_json::json;
+use sc_cli::{
+    OutputType,
+    utils::{PublicFor, SeedFor},
+};
+use sp_runtime::{traits::IdentifyAccount, MultiSigner};
+use sp_core::{
+    crypto::{
+        unwrap_or_default_ss58_version,
+        Ss58Codec, ExposeSecret, Ss58AddressFormat, SecretString,
+    },
+    hexdisplay::HexDisplay,
+};
+
+pub fn print_from_uri<Pair>(
+	uri: &str,
+	password: Option<SecretString>,
+	network_override: Option<Ss58AddressFormat>,
+	output: OutputType,
+) where
+	Pair: sp_core::Pair,
+	Pair::Public: Into<MultiSigner>,
+{
+	let password = password.as_ref().map(|s| s.expose_secret().as_str());
+	let network_id = unwrap_or_default_ss58_name(network_override);
+
+	if let Ok((pair, seed)) = Pair::from_phrase(uri, password) {
+		let public_key = pair.public();
+		let network_override = unwrap_or_default_ss58_version(network_override);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"secretPhrase": uri,
+					"networkId": network_id,
+					"secretSeed": format_seed::<Pair>(seed),
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"accountId": format_account_id::<Pair>(public_key),
+					"ss58Address": pair.public().into().into_account().to_ss58check_with_version(network_override),
+				});
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Secret phrase:       {}\n  \
+					Network ID:        {}\n  \
+					Secret seed:       {}\n  \
+					Public key (hex):  {}\n  \
+					Account ID:        {}\n  \
+					Public key (SS58): {}\n  \
+					SS58 Address:      {}",
+					uri,
+					network_id,
+					format_seed::<Pair>(seed),
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					pair.public().into().into_account().to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else if let Ok((pair, seed)) = Pair::from_string_with_seed(uri, password) {
+		let public_key = pair.public();
+		let network_override = unwrap_or_default_ss58_version(network_override);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"secretKeyUri": uri,
+					"networkId": network_id,
+					"secretSeed": if let Some(seed) = seed { format_seed::<Pair>(seed) } else { "n/a".into() },
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"accountId": format_account_id::<Pair>(public_key),
+					"ss58Address": pair.public().into().into_account().to_ss58check_with_version(network_override),
+				});
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Secret Key URI `{}` is account:\n  \
+					Network ID:        {}\n  \
+					Secret seed:       {}\n  \
+					Public key (hex):  {}\n  \
+					Account ID:        {}\n  \
+					Public key (SS58): {}\n  \
+					SS58 Address:      {}",
+					uri,
+					network_id,
+					if let Some(seed) = seed { format_seed::<Pair>(seed) } else { "n/a".into() },
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					pair.public().into().into_account().to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else if let Ok((public_key, network)) = Pair::Public::from_string_with_version(uri) {
+		let network_override = network_override.unwrap_or(network);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"publicKeyUri": uri,
+					"networkId": String::from(network_override),
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"accountId": format_account_id::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"ss58Address": public_key.to_ss58check_with_version(network_override),
+				});
+
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Public Key URI `{}` is account:\n  \
+					 Network ID/Version: {}\n  \
+					 Public key (hex):   {}\n  \
+					 Account ID:         {}\n  \
+					 Public key (SS58):  {}\n  \
+					 SS58 Address:       {}",
+					uri,
+					String::from(network_override),
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					public_key.to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else {
+		println!("Invalid phrase/URI given");
+	}
+}
+
+/// Try to parse given `public` as hex encoded public key and print relevant information.
+pub fn print_from_public<Pair>(
+	public_str: &str,
+	network_override: Option<Ss58AddressFormat>,
+	output: OutputType,
+) -> Result<(), sc_cli::Error>
+where
+	Pair: sp_core::Pair,
+	Pair::Public: Into<MultiSigner>,
+{
+	let public = array_bytes::hex2bytes(public_str)?;
+
+	let public_key = Pair::Public::try_from(&public)
+		.map_err(|_| "Failed to construct public key from given hex")?;
+
+	let network_override = unwrap_or_default_ss58_version(network_override);
+
+	match output {
+		OutputType::Json => {
+			let json = json!({
+				"networkId": String::from(network_override),
+				"publicKey": format_public_key::<Pair>(public_key.clone()),
+				"accountId": format_account_id::<Pair>(public_key.clone()),
+				"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+				"ss58Address": public_key.to_ss58check_with_version(network_override),
+			});
+
+			println!("{}", serde_json::to_string_pretty(&json).expect("Json pretty print failed"));
+		},
+		OutputType::Text => {
+			println!(
+				"Network ID/Version: {}\n  \
+				 Public key (hex):   {}\n  \
+				 Account ID:         {}\n  \
+				 Public key (SS58):  {}\n  \
+				 SS58 Address:       {}",
+				String::from(network_override),
+				format_public_key::<Pair>(public_key.clone()),
+				format_account_id::<Pair>(public_key.clone()),
+				public_key.to_ss58check_with_version(network_override),
+				public_key.to_ss58check_with_version(network_override),
+			);
+		},
+	}
+
+	Ok(())
+}
+
+pub fn unwrap_or_default_ss58_name(x: Option<Ss58AddressFormat>) -> String {
+    if let Some(x) = x {
+        let name = match x.prefix() {
+            1995 => String::from("Ghost"),
+            1996 => String::from("Casper"),
+            _ => String::from("Unwknown"),
+        };
+        format!("{} ({})", name, x.prefix())
+    } else {
+        String::from("Unknown (unknown)")
+    }
+}
+
+pub fn format_seed<P: sp_core::Pair>(seed: SeedFor<P>) -> String {
+    format!("0x{}", HexDisplay::from(&seed.as_ref()))
+}
+
+fn format_public_key<P: sp_core::Pair>(public_key: PublicFor<P>) -> String {
+    format!("0x{}", HexDisplay::from(&public_key.as_ref()))
+}
+
+fn format_account_id<P: sp_core::Pair>(public_key: PublicFor<P>) -> String
+where
+    PublicFor<P>: Into<MultiSigner>,
+{
+    format!("0x{}", HexDisplay::from(&public_key.into().into_account().as_ref()))
+}

client/cli/src/commands/vanity.rs

@@ -0,0 +1,214 @@
+//! implementation of the `vanity` subcommand
+
+use clap::Parser;
+use rand::{rngs::OsRng, RngCore};
+use sp_core::crypto::{
+    unwrap_or_default_ss58_version, Ss58AddressFormat, Ss58Codec,
+};
+use sp_runtime::traits::IdentifyAccount;
+use sc_cli::{
+    with_crypto_scheme, Error, OutputTypeFlag, CryptoSchemeFlag,
+    utils::format_seed,
+};
+
+use crate::commands::utils::print_from_uri;
+use crate::params::NetworkSchemeFlag;
+
+/// The `vanity` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "vanity", about = "Generate a seed that provides a vanity address")]
+pub struct VanityCmd {
+	/// Desired pattern
+	#[arg(long, value_parser = assert_non_empty_string)]
+	pattern: String,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	crypto_scheme: CryptoSchemeFlag,
+}
+
+impl VanityCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let formated_seed = with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			generate_key(
+				&self.pattern,
+				unwrap_or_default_ss58_version(self.network_scheme.network)
+			),
+		)?;
+
+		with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			print_from_uri(
+				&formated_seed,
+				None,
+				self.network_scheme.network,
+				self.output_scheme.output_type,
+			),
+		);
+		Ok(())
+	}
+}
+
+/// genertae a key based on given pattern
+fn generate_key<Pair>(
+	desired: &str,
+	network_override: Ss58AddressFormat,
+) -> Result<String, &'static str>
+where
+	Pair: sp_core::Pair,
+	Pair::Public: IdentifyAccount,
+	<Pair::Public as IdentifyAccount>::AccountId: Ss58Codec,
+{
+	println!("Generating key containing pattern '{}'", desired);
+
+	let top = 45 + (desired.len() * 48);
+	let mut best = 0;
+	let mut seed = Pair::Seed::default();
+	let mut done = 0;
+
+	loop {
+		if done % 100000 == 0 {
+			OsRng.fill_bytes(seed.as_mut());
+		} else {
+			next_seed(seed.as_mut());
+		}
+
+		let p = Pair::from_seed(&seed);
+		let ss58 = p.public().into_account().to_ss58check_with_version(network_override);
+        println!("{:?}", ss58);
+		let score = calculate_score(desired, &ss58);
+		if score > best || desired.len() < 2 {
+			best = score;
+			if best >= top {
+				println!("best: {} == top: {}", best, top);
+				return Ok(format_seed::<Pair>(seed.clone()))
+			}
+		}
+		done += 1;
+
+		if done % good_waypoint(done) == 0 {
+			println!("{} keys searched; best is {}/{} complete", done, best, top);
+		}
+	}
+}
+
+fn good_waypoint(done: u64) -> u64 {
+	match done {
+		0..=1_000_000 => 100_000,
+		1_000_001..=10_000_000 => 1_000_000,
+		10_000_001..=100_000_000 => 10_000_000,
+		100_000_001.. => 100_000_000,
+	}
+}
+
+fn next_seed(seed: &mut [u8]) {
+	for s in seed {
+		match s {
+			255 => {
+				*s = 0;
+			},
+			_ => {
+				*s += 1;
+				break
+			},
+		}
+	}
+}
+
+/// Calculate the score of a key based on the desired
+/// input.
+fn calculate_score(_desired: &str, key: &str) -> usize {
+	for truncate in 0.._desired.len() {
+		let snip_size = _desired.len() - truncate;
+		let truncated = &_desired[0..snip_size];
+		if let Some(pos) = key.find(truncated) {
+			return (47 - pos) + (snip_size * 48)
+		}
+	}
+	0
+}
+
+/// checks that `pattern` is non-empty
+fn assert_non_empty_string(pattern: &str) -> Result<String, &'static str> {
+	if pattern.is_empty() {
+		Err("Pattern must not be empty")
+	} else {
+		Ok(pattern.to_string())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{
+		crypto::{default_ss58_version, Ss58AddressFormatRegistry, Ss58Codec},
+		sr25519, Pair,
+	};
+
+	#[test]
+	fn vanity() {
+		let vanity = VanityCmd::parse_from(&["vanity", "--pattern", "j"]);
+		assert!(vanity.run().is_ok());
+	}
+
+	#[test]
+	fn test_generation_with_single_char() {
+		let seed = generate_key::<sr25519::Pair>("ab", default_ss58_version()).unwrap();
+		assert!(sr25519::Pair::from_seed_slice(&array_bytes::hex2bytes_unchecked(&seed))
+			.unwrap()
+			.public()
+			.to_ss58check()
+			.contains("ab"));
+	}
+
+	#[test]
+	fn generate_key_respects_network_override() {
+		let seed =
+			generate_key::<sr25519::Pair>("ab", Ss58AddressFormatRegistry::PolkadotAccount.into())
+				.unwrap();
+		assert!(sr25519::Pair::from_seed_slice(&array_bytes::hex2bytes_unchecked(&seed))
+			.unwrap()
+			.public()
+			.to_ss58check_with_version(Ss58AddressFormatRegistry::PolkadotAccount.into())
+			.contains("ab"));
+	}
+
+	#[test]
+	fn test_score_1_char_100() {
+		let score = calculate_score("j", "sYrjWiZkEP1PQe2kKEZiC1Bi9L8yFSsB5RPEkzEPd5NThsB5H");
+		assert_eq!(score, 96);
+	}
+
+	#[test]
+	fn test_score_100() {
+		let score = calculate_score("ghst", "sYsghstuhYd9p6unUC3kPxjD2gv2zRCztYQaEDCMJpYrPTqTG");
+		assert_eq!(score, 246);
+	}
+
+	#[test]
+	fn test_score_50_2() {
+		// 50% for the position + 50% for the size
+		assert_eq!(
+			calculate_score("ghst", "sYsghXXuhYd9p6unUC3kPxjD2gv2zRCztYQaEDCMJpYrPTqTG"),
+			146
+		);
+	}
+
+	#[test]
+	fn test_score_0() {
+		assert_eq!(
+			calculate_score("ghst", "sYrjWiZkEP1PQe2kKEZiC1Bi9L8yFSsB5RPEkzEPd5NThsB5H"),
+			0
+		);
+	}
+}

client/cli/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod params;
+pub mod commands;
+
+pub use commands::KeySubcommand;
+pub use commands::VanityCmd;

client/cli/src/params/mod.rs

@@ -0,0 +1,70 @@
+use clap::Args;
+use sp_core::crypto::Ss58AddressFormat;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct ParseError;
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "failed to parse network value as u16")
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+static ALL_POSSIBLE_NAMES: [&str; 2] = ["ghost", "casper"];
+static ALL_POSSIBLE_IDS: [u16; 2] = [1995, 1996];
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct InnerSs58AddressFormat(Ss58AddressFormat);
+
+impl InnerSs58AddressFormat {
+    #[inline]
+    pub fn custom(prefix: u16) -> Self {
+        Self { 0: Ss58AddressFormat::custom(prefix) }
+    }
+}
+
+impl std::fmt::Display for InnerSs58AddressFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} network", ALL_POSSIBLE_IDS
+            .binary_search(&u16::from(self.0))
+            .expect("always be found"))
+    }
+}
+
+impl<'a>TryFrom<&'a str> for InnerSs58AddressFormat {
+    type Error = ParseError;
+
+    fn try_from(x: &'a str) -> Result<Self, Self::Error> {
+        match ALL_POSSIBLE_NAMES.iter().position(|&n| n == x) {
+            Some(id) => Ok(InnerSs58AddressFormat::custom(ALL_POSSIBLE_IDS[id])),
+            _ => Err(ParseError),
+        }
+    }
+}
+
+pub fn parse_s58_prefix_address_format(x: &str,) -> Result<Ss58AddressFormat, String> {
+    match InnerSs58AddressFormat::try_from(x) {
+        Ok(format_registry) => Ok(format_registry.0.into()),
+        Err(_) => Err(format!(
+            "Unable to parse variant. Known variants: {:?}",
+            &ALL_POSSIBLE_NAMES
+        ))
+    }
+}
+
+/// Optional flag for specifying network scheme
+#[derive(Debug, Clone, Args)]
+pub struct NetworkSchemeFlag {
+    /// Network address format
+    #[arg(
+        short = 'n',
+        long,
+        ignore_case = true,
+        value_parser = parse_s58_prefix_address_format,
+        value_name = "NETWORK",
+        default_value = "casper",
+    )]
+    pub network: Option<Ss58AddressFormat>,
+}