vanity move address

Cargo.toml

@@ -38,6 +38,7 @@ members = [
   "util/signing/providers/aws-kms",
   "util/signing/providers/hashicorp-vault",
   "util/signing/testing",
+  "util/vanity",
   "demo/hsm",
   "protocol-units/execution/maptos/framework/releases/*",
   "protocol-units/execution/maptos/framework/migrations/*",

util/vanity/.gitignore

@@ -0,0 +1 @@
+/target

util/vanity/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "vanity"
+version = "0.2.1"
+edition = "2021"
+
+[dependencies]
+aptos-sdk = { workspace = true }
+rand = { workspace = true }
+rayon = { workspace = true }
+hex = { workspace = true }
+clap = { workspace = true }
+thiserror = { workspace = true }
+num_cpus = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+assert_cmd = "2"
+predicates = "3"
+
+
+[[bin]]
+name = "vanity"
+path = "src/main.rs"

util/vanity/README.md

@@ -0,0 +1,18 @@
+# Vanity 🧂⛏️
+
+Vanity is a CLI for mining vanity move addresses.
+
+Vanity is heavily inspired by [Create2Crunch](https://github.com/0age/create2crunch).
+
+## Installation
+
+```bash
+git clone https://github.com/movementlabsxyz/movement.git
+cd movement
+# Run it directly
+RUST_LOG=info cargo run -p vanity --release -- move --starts <STARTS_PATTERN> --ends <ENDS_PATTERN>
+
+cd util/vanity
+# Add it to your path
+cargo install --path .
+```

util/vanity/src/cli.rs

@@ -0,0 +1,184 @@
+use clap::{Parser, Subcommand};
+use std::{ops::Deref, str::FromStr};
+
+/// Pattern type for hex string filtering.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Pattern(Box<str>);
+
+impl Deref for Pattern {
+	type Target = str;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl Pattern {
+	/// Return the raw hex string without trying to decode it.
+	pub fn as_str(&self) -> &str {
+		&self.0
+	}
+}
+
+/// Pattern parsing errors.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum PatternError {
+	#[error("the pattern's length exceeds 39 characters or the pattern is empty")]
+	InvalidPatternLength,
+	#[error("the pattern is not in hexadecimal format")]
+	NonHexPattern,
+}
+
+impl FromStr for Pattern {
+	type Err = PatternError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		if s.len() >= 40 || s.is_empty() {
+			return Err(PatternError::InvalidPatternLength);
+		}
+		if s.chars().any(|c| !c.is_ascii_hexdigit()) {
+			return Err(PatternError::NonHexPattern);
+		}
+		Ok(Self(s.into()))
+	}
+}
+
+/// CLI definition for the `vanity` tool.
+#[derive(Parser, Debug)]
+#[command(name = "vanity", about = "Vanity is a fast vanity address miner.")]
+pub struct Cli {
+	#[command(subcommand)]
+	pub command: Vanity,
+}
+
+/// Supported CLI subcommands.
+#[derive(Debug, Subcommand)]
+pub enum Vanity {
+	Move {
+		#[clap(long)]
+		starts: Option<String>,
+		#[clap(long)]
+		ends: Option<String>,
+	},
+	Resource {
+		#[clap(long)]
+		address: Option<String>,
+		#[clap(long)]
+		starts: Option<String>,
+		#[clap(long)]
+		ends: Option<String>,
+	},
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{Cli, Pattern, Vanity};
+	use assert_cmd::Command;
+	use clap::Parser;
+	use std::str::FromStr;
+
+	#[test]
+	fn test_valid_pattern() {
+		let p = Pattern::from_str("abcd").unwrap();
+		assert_eq!(&*p, "abcd");
+	}
+
+	#[test]
+	fn test_cli_parsing_starts() {
+		let cli = Cli::parse_from(["vanity", "move", "--starts", "abcd"]);
+		match cli.command {
+			Vanity::Move { starts, ends } => {
+				assert_eq!(starts, Some("abcd".to_string()));
+				assert_eq!(ends, None);
+			}
+			_ => panic!("Expected Move variant"),
+		}
+	}
+
+	#[test]
+	fn test_resource_parsing_starts() {
+		let cli = Cli::parse_from([
+			"vanity",
+			"resource",
+			"--address",
+			"0x5e04c2f5bf1a89d3431d2c047626acbba41c900a69b10e7c24e5b919802c531f",
+			"--starts",
+			"abcd",
+		]);
+		match cli.command {
+			Vanity::Resource { address, starts, ends } => {
+				assert_eq!(
+					address,
+					Some(
+						"0x5e04c2f5bf1a89d3431d2c047626acbba41c900a69b10e7c24e5b919802c531f"
+							.to_string()
+					)
+				);
+				assert_eq!(starts, Some("abcd".to_string()));
+				assert_eq!(ends, None);
+			}
+			_ => panic!("Expected Resource variant"),
+		}
+	}
+
+	#[test]
+	fn test_cli_runs_with_starts() {
+		let mut cmd = Command::cargo_bin("vanity").unwrap();
+		let assert = cmd.args(&["move", "--starts", "de"]).assert().success();
+
+		let output = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+		let address_line = output.lines().find(|l| l.contains("Found Move address:")).unwrap();
+		let address = address_line.split(':').nth(1).unwrap().trim().trim_start_matches("0x");
+
+		assert!(address.starts_with("de"), "Address does not start with 'de': {}", address);
+	}
+
+	#[test]
+	fn test_cli_runs_with_ends() {
+		let mut cmd = Command::cargo_bin("vanity").unwrap();
+		let assert = cmd.args(&["move", "--ends", "f0"]).assert().success();
+
+		let output = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+		let address_line = output.lines().find(|l| l.contains("Found Move address:")).unwrap();
+		let address = address_line.split(':').nth(1).unwrap().trim().trim_start_matches("0x");
+
+		assert!(address.ends_with("f0"), "Address does not end with 'f0': {}", address);
+	}
+
+	#[test]
+	fn test_cli_runs_with_starts_and_ends() {
+		let mut cmd = Command::cargo_bin("vanity").unwrap();
+		let assert = cmd.args(&["move", "--starts", "de", "--ends", "f0"]).assert().success();
+
+		let output = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+		let address_line = output.lines().find(|l| l.contains("Found Move address:")).unwrap();
+		let address = address_line.split(':').nth(1).unwrap().trim().trim_start_matches("0x");
+
+		assert!(address.starts_with("de"), "Address does not start with 'de': {}", address);
+		assert!(address.ends_with("f0"), "Address does not end with 'f0': {}", address);
+	}
+
+	#[test]
+	fn test_resource_runs_with_starts_and_ends() {
+		let mut cmd = Command::cargo_bin("vanity").unwrap();
+		let assert = cmd
+			.args(&[
+				"resource",
+				"--address",
+				"0x5e04c2f5bf1a89d3431d2c047626acbba41c900a69b10e7c24e5b919802c531f",
+				"--starts",
+				"de",
+				"--ends",
+				"f0",
+			])
+			.assert()
+			.success();
+
+		let output = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+		let address_line = output.lines().find(|l| l.contains("Found Resource Address:")).unwrap();
+		let address = address_line.split(':').nth(1).unwrap().trim().trim_start_matches("0x");
+
+		assert!(address.starts_with("de"), "Address does not start with 'de': {}", address);
+		assert!(address.ends_with("f0"), "Address does not end with 'f0': {}", address);
+	}
+}

util/vanity/src/main.rs

@@ -0,0 +1,64 @@
+mod cli;
+mod miner;
+
+use aptos_sdk::types::account_address::AccountAddress;
+use clap::Parser;
+use std::str::FromStr;
+
+use cli::{Cli, Pattern, Vanity};
+
+use miner::{mine_move_address, mine_resource_address};
+use num_cpus;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+	let cli = Cli::parse();
+
+	match cli.command {
+		Vanity::Move { starts, ends } => {
+			let starts_str = if let Some(s) = starts {
+				Pattern::from_str(&s)?;
+				s
+			} else {
+				String::new()
+			};
+			let ends_str = if let Some(s) = ends {
+				Pattern::from_str(&s)?;
+				s
+			} else {
+				String::new()
+			};
+
+			let account = mine_move_address(&starts_str, &ends_str, num_cpus::get());
+
+			println!("Found Move address: {}", account.address());
+			println!("Private key (hex): {}", hex::encode(account.private_key().to_bytes()));
+		}
+		Vanity::Resource { address, starts, ends } => {
+			let address = match address {
+				Some(ref a) => AccountAddress::from_str(a)?,
+				None => return Err("Move address is required".into()),
+			};
+
+			let starts_str = if let Some(s) = starts {
+				Pattern::from_str(&s)?;
+				s
+			} else {
+				String::new()
+			};
+			let ends_str = if let Some(s) = ends {
+				Pattern::from_str(&s)?;
+				s
+			} else {
+				String::new()
+			};
+
+			let (resource_address, seed) =
+				mine_resource_address(&address, &starts_str, &ends_str, num_cpus::get());
+
+			println!("Found Resource Address: {}", resource_address);
+			println!("Seed: {}", hex::encode(seed));
+		}
+	}
+
+	Ok(())
+}