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,13 @@
+[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 }

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
+cargo run -p vanity --release -- move --starts-pattern <STARTS_PATTERN> --ends-pattern <ENDS_PATTERN>
+
+cd util/vanity
+# Add it to your path
+cargo install --path .
+```

util/vanity/src/cli.rs

@@ -0,0 +1,61 @@
+use std::{ops::Deref, str::FromStr};
+
+/// Pattern.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(super) struct Pattern(Box<str>);
+
+impl Deref for Pattern {
+	type Target = str;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl Pattern {
+	pub(super) fn into_bytes(self) -> Result<Vec<u8>, hex::FromHexError> {
+		let mut string = self.to_string();
+
+		if self.len() % 2 != 0 {
+			string += "0"
+		};
+
+		hex::decode(string)
+	}
+}
+
+/// Pattern errors.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
+pub(super) 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()))
+	}
+}
+
+#[derive(Clone, Debug, clap::Parser)]
+#[command(name = "vanity", about = "Vanity is a fast vanity address miner.")]
+pub(super) enum Vanity {
+	Move {
+        #[clap(long)]
+		starts_pattern: Option<String>,
+        #[clap(long)]
+		ends_pattern: Option<String>,
+	},
+}

util/vanity/src/main.rs

@@ -0,0 +1,33 @@
+mod cli;
+mod miner;
+
+use std::str::FromStr;
+use clap::Parser;
+use cli::{Pattern, Vanity};
+use miner::mine_move_address;
+use num_cpus;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    match Vanity::parse() {
+        Vanity::Move { starts_pattern, ends_pattern } => {
+            let starts_pattern_bytes = match starts_pattern {
+                Some(p) => Pattern::from_str(&p)?.into_bytes()?,
+                None => vec![],
+            };
+            let ends_pattern_bytes = match ends_pattern {
+                Some(p) => Pattern::from_str(&p)?.into_bytes()?,
+                None => vec![],
+            };
+
+            let account = mine_move_address(
+                &starts_pattern_bytes,
+                &ends_pattern_bytes,
+                num_cpus::get(),
+            );
+
+            println!("Found Move address: {}", account.address());
+            println!("Private key (hex): {}", hex::encode(account.private_key().to_bytes()));
+            return Ok(());
+        }
+    }
+}

util/vanity/src/miner.rs

@@ -0,0 +1,55 @@
+use aptos_sdk::types::{account_address::AccountAddress, LocalAccount};
+use rand::thread_rng;
+use rayon::prelude::*;
+use rayon::ThreadPoolBuilder;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc, Mutex,
+};
+use std::time::Instant;
+
+fn matches_pattern(addr: &AccountAddress, start: &[u8], end: &[u8]) -> bool {
+    let addr_bytes = addr.to_vec();
+    (start.is_empty() || addr_bytes.starts_with(start)) &&
+    (end.is_empty() || addr_bytes.ends_with(end))
+}
+
+pub fn mine_move_address(
+    starts_pattern: &[u8],
+    ends_pattern: &[u8],
+    threads: usize,
+) -> LocalAccount {
+    let found = Arc::new(AtomicBool::new(false));
+    let result = Arc::new(Mutex::new(None));
+    let start_time = Instant::now();
+
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(threads)
+        .build()
+        .expect("Failed to build thread pool");
+
+    pool.install(|| {
+        (0u64..=u64::MAX)
+            .into_par_iter()
+            .find_any(|_| {
+                if found.load(Ordering::Relaxed) {
+                    return false;
+                }
+                let mut rng = thread_rng();
+                let account = LocalAccount::generate(&mut rng);
+                if matches_pattern(&account.address(), starts_pattern, ends_pattern) {
+                    let mut lock = result.lock().unwrap();
+                    *lock = Some(account);
+                    found.store(true, Ordering::Relaxed);
+                    true
+                } else {
+                    false
+                }
+            });
+    });
+
+    println!("✅ Mining completed in {:?}", start_time.elapsed());
+
+    let final_result = std::mem::take(&mut *result.lock().unwrap());
+    final_result.expect("No matching account found")
+}