vanity-eth

README

Vanity-ETH

A high-performance Ethereum vanity address generator that creates BIP39 mnemonic phrases matching specific address patterns. Generate memorable Ethereum addresses with custom suffixes while maintaining full compatibility with standard HD wallet derivation paths.

🌟 Features

• BIP39 Compliant: Generates standard 12-word mnemonic phrases
• Ethereum Compatible: Uses BIP44 derivation path (m/44'/60'/0'/0/0)
• High Performance: Multi-threaded generation using all available CPU cores
• Custom Suffix Matching: Find addresses ending with your desired pattern
• Real-time Progress: Visual progress bar and attempt counter
• Cross-platform: Works on Windows, macOS, and Linux

📋 Prerequisites

• Go 1.24.0 or higher
• Git (for installation)

🚀 Installation

From Source

git clone https://github.com/yosebyte/vanity-eth.git
cd vanity-eth
go mod download
go build -o vanity-eth

Using Go Install

go install github.com/yosebyte/vanity-eth@latest

💻 Usage

Basic Usage

Generate an address with a specific suffix:

./vanity-eth -match "abc"

Advanced Options

./vanity-eth -match "1234" -max 1000000 -workers 8

Command-line Options

Flag	Description	Default
-match	String to match at the end of address (suffix)	"" (empty)
-max	Maximum number of attempts	100000
-workers	Number of concurrent workers	Number of CPU cores

Examples

Generate an address ending with "cafe":

./vanity-eth -match "cafe"

Generate with 1 million max attempts:

./vanity-eth -match "abcdef" -max 1000000

Use 16 workers for faster generation:

./vanity-eth -match "1234" -workers 16

📊 Example Output

Generating BIP39 mnemonic and ETH address...
Match suffix: cafe
Max attempts: 100000
Using 8 concurrent workers

[####################                              ] 42.5% Attempts: 42500 / 100000

Found matching address after 43234 attempts!
Time taken: 5.234s
Mnemonic: abandon ability able about above absent absorb abstract absurd abuse access accident
Address (m/44'/60'/0'/0/0): 0x742d35Cc6634C0532925a3b844Bc9e7595f4cafe

⚙️ How It Works

1. Entropy Generation: Creates cryptographically secure random entropy (128 bits)
2. Mnemonic Creation: Converts entropy to BIP39 mnemonic phrase (12 words)
3. Seed Generation: Derives seed from mnemonic using PBKDF2
4. Key Derivation: Follows BIP44 path m/44'/60'/0'/0/0 for Ethereum
5. Address Generation: Computes Ethereum address from public key
6. Pattern Matching: Checks if address suffix matches desired pattern
7. Result Output: Returns mnemonic and address when match is found

🔐 Security Considerations

• USE AT YOUR OWN RISK: Vanity addresses take time to generate; the longer the pattern, the exponentially longer it takes
• Entropy Source: Uses crypto/rand for cryptographically secure random number generation
• No Passphrase: Default implementation uses empty passphrase for BIP39 seed
• Derivation Path: Standard Ethereum path m/44'/60'/0'/0/0
• Private Keys: Never share your mnemonic phrase or private keys
• Backup: Always backup your mnemonic phrase securely

📈 Performance

Generation speed depends on:

• CPU performance and number of cores
• Pattern length (each additional character multiplies difficulty by ~16)
• System load

Estimated Times (on modern CPU, 8 cores):

• 1 character: Instant
• 2 characters: < 1 second
• 3 characters: 1-5 seconds
• 4 characters: 10-60 seconds
• 5 characters: 5-20 minutes
• 6 characters: 1-5 hours
• 7+ characters: hours to days

📝 License

This project is licensed under the BSD 3-Clause License - see the LICENSE file for details.

⚠️ Disclaimer

This tool is provided as-is without any warranties. The generated mnemonic phrases are as secure as the entropy source used. Always verify the security of any generated keys before using them with real funds. The authors are not responsible for any loss of funds.

🔗 Related Projects

• BIP39 Specification
• BIP44 Specification
• go-ethereum
• btcd

Documentation

Overview

Package main implements an Ethereum vanity address generator with BIP39 mnemonic phrase support. It generates random mnemonic phrases and derives Ethereum addresses until finding one that matches the specified suffix pattern.