vanity-core 0.8.1

Multi-chain vanity address grinding core library
Documentation
use crate::chain::{ChainGrinder, GrindAttempt, KeyExport, KeypairResult};
use crate::pattern::Pattern;
use rand::rngs::OsRng;
use secp256k1::{Secp256k1, SecretKey};
use sha3::{Digest, Keccak256};

use super::util::{
    build_hex_pattern, expected_from_pattern, hex_combinations, matches_pattern,
    secret_from_attempt,
};

#[derive(Clone, Default)]
pub struct EvmGrinder;

impl EvmGrinder {
    fn derive_address(secret_key: &SecretKey) -> String {
        let secp = Secp256k1::new();
        let public_key = secret_key.public_key(&secp);
        let public_bytes = &public_key.serialize_uncompressed()[1..];
        let hash = Keccak256::digest(public_bytes);
        format!("0x{}", hex::encode(&hash[12..]))
    }
}

impl ChainGrinder for EvmGrinder {
    fn id(&self) -> &'static str {
        "evm"
    }

    fn display_name(&self) -> &'static str {
        "EVM (Ethereum)"
    }

    fn grind_attempt(&self) -> (String, GrindAttempt) {
        let mut rng = OsRng;
        let secret_key = SecretKey::new(&mut rng);
        let address = Self::derive_address(&secret_key);
        (address, GrindAttempt::Secret32(secret_key.secret_bytes()))
    }

    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
        let secret_bytes = secret_from_attempt(attempt);
        let address = {
            let secret_key = SecretKey::from_slice(&secret_bytes).expect("valid secp256k1 secret");
            Self::derive_address(&secret_key)
        };

        KeypairResult {
            address,
            exports: vec![
                KeyExport {
                    label: "Private Key (hex)".into(),
                    value: hex::encode(secret_bytes),
                    hint: Some("MetaMask → Import account → Private key".into()),
                },
                KeyExport {
                    label: "Private Key (0x hex)".into(),
                    value: format!("0x{}", hex::encode(secret_bytes)),
                    hint: Some("ethers.js / viem / Foundry / Hardhat".into()),
                },
            ],
        }
    }

    fn build_pattern(
        &self,
        prefix: Option<&str>,
        suffix: Option<&str>,
        contains: Option<&str>,
        _exact: bool,
    ) -> Result<Pattern, String> {
        build_hex_pattern(prefix, suffix, contains, true, 40)
    }

    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
        expected_from_pattern(pattern, hex_combinations)
    }

    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
        matches_pattern(address, pattern, true)
    }

    fn supports_exact_case(&self) -> bool {
        false
    }

    fn pattern_hint(&self) -> &'static str {
        "Hex characters (0-9, a-f). Optional 0x prefix."
    }
}

#[cfg(test)]
mod tests {
    use super::EvmGrinder;
    use crate::chain::ChainGrinder;

    #[test]
    fn evm_prefix_normalizes_0x() {
        let g = EvmGrinder;
        let p = g
            .build_pattern(Some("dead"), Some("face"), None, false)
            .unwrap();
        assert_eq!(p.prefix_match, "0xdead");
        assert_eq!(p.suffix_match, "face");
    }

    #[test]
    fn evm_rejects_invalid_hex() {
        let g = EvmGrinder;
        assert!(g.build_pattern(Some("zzzz"), None, None, false).is_err());
    }

    #[test]
    fn evm_matches_address() {
        let g = EvmGrinder;
        let p = g
            .build_pattern(Some("dead"), Some("face"), None, false)
            .unwrap();
        assert!(g.matches("0xdead000000000000000000000000000000face", &p));
        assert!(!g.matches("0xface000000000000000000000000000000dead", &p));
    }
}