forc-crypto: vanity address generation

forc-plugins/forc-crypto/Cargo.toml

@@ -17,15 +17,26 @@ forc-tracing.workspace = true
 forc-util.workspace = true
 fuel-core-types.workspace = true
 fuel-crypto = { workspace = true, features = ["random"] }
+fuels-accounts.workspace = true
 fuels-core.workspace = true
 futures.workspace = true
 hex.workspace = true
 libp2p-identity = { workspace = true, features = ["peerid", "secp256k1"] }
 rand.workspace = true
+rayon.workspace = true
+regex.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_yaml.workspace = true
 sha3.workspace = true
 termion.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "process"] }
 tracing.workspace = true
+
+[dev-dependencies]
+criterion = "0.5"
+tempfile.workspace = true
+
+[[bench]]
+name = "bench_main"
+harness = false

forc-plugins/forc-crypto/benches/bench_main.rs

@@ -0,0 +1,73 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use forc_crypto::keys::vanity::{find_vanity_address_with_timeout, HexMatcher, RegexMatcher};
+use rayon::iter::Either;
+
+fn benchmark_vanity_address(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Vanity Address Generation");
+
+    // Benchmark HexMatcher with prefix
+    group.bench_function("HexMatcher (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark HexMatcher with suffix
+    group.bench_function("HexMatcher (ends with 'f')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("", "f").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark HexMatcher with both prefix and suffix
+    group.bench_function("HexMatcher (starts with 'a' ends with 'f')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "f").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark RegexMatcher with simple pattern
+    group.bench_function("RegexMatcher (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new("^a.*").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark RegexMatcher with complex pattern
+    group.bench_function("RegexMatcher (contains two consecutive digits)", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new(r"[0-9]{2}").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), false, None)
+        })
+    });
+
+    // Benchmark with mnemonic generation
+    group.bench_function("HexMatcher with Mnemonic (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Right(HexMatcher::new("a", "").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), true, None)
+        })
+    });
+
+    group.bench_function("RegexMatcher with Mnemonic (starts with 'a')", |b| {
+        b.iter(|| {
+            let matcher = Either::Left(RegexMatcher::new("^a.*").unwrap());
+            find_vanity_address_with_timeout(black_box(matcher), true, None)
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(10) // Reduced sample size due to potentially long-running benchmarks
+        .measurement_time(std::time::Duration::from_secs(20));
+    targets = benchmark_vanity_address
+}
+criterion_main!(benches);

forc-plugins/forc-crypto/src/keys/mod.rs

@@ -3,6 +3,7 @@ use clap::ValueEnum;
 pub mod get_public_key;
 pub mod new_key;
 pub mod parse_secret;
+pub mod vanity;
 
 #[derive(Clone, Debug, Default, ValueEnum)]
 pub enum KeyType {