VanityUltra 🔑

VanityUltra is a high-performance Solana vanity wallet generator written in C#. It uses multi-threading and cryptographic primitives to generate Solana addresses that match custom patterns — ideal for branding, exclusivity, or personal flair.

🚀 Features

• High Performance: Multi-threaded generation using all available CPU cores
• Cryptographically Secure: Uses NSec.Cryptography for Ed25519 key generation
• Base58 Encoding: Proper Solana address encoding with SimpleBase
• Progress Tracking: Real-time progress updates with ETA calculations
• Configuration Support: Customizable settings via JSON configuration
• Multi-Process Mode: Distribute work across multiple processes for maximum performance
• Comprehensive Validation: Input validation and error handling
• Unit Tests: Full test coverage for core functionality

📦 Requirements

• .NET 9 SDK
• NuGet packages:
  • SimpleBase v4.0.0
  • NSec.Cryptography v24.4.0
  • xunit v2.6.1 (for tests)

🛠️ Build Instructions

# Build the main project
dotnet build -c Release

# Run tests
dotnet test

# Publish for deployment
dotnet publish -c Release -r win-x64 --self-contained true

🎯 Usage

Basic Usage

# Interactive mode
dotnet run

# Command line mode
dotnet run -- sol
dotnet run -- moon
dotnet run -- 1234

Multi-Process Mode (High Performance)

# Launch multiple processes for maximum performance
dotnet run -- mega sol

Configuration

Create a config.json file to customize behavior:

{
  "MaxThreads": 0,
  "BatchSize": 5000,
  "ProgressUpdateIntervalMs": 2000,
  "CaseSensitive": false,
  "VerboseOutput": true
}

Configuration Options:

• MaxThreads: Maximum number of threads (0 = auto-detect)
• BatchSize: Keys generated per batch per thread
• ProgressUpdateIntervalMs: Progress update frequency in milliseconds
• CaseSensitive: Whether vanity pattern matching is case-sensitive
• VerboseOutput: Enable detailed progress reporting

📊 Performance

The generator is optimized for maximum performance:

• Threading: Uses CPU cores efficiently with minimal contention
• Batch Processing: Processes keys in batches to reduce overhead
• Memory Management: Optimized memory usage with proper disposal
• Progress Reporting: Minimal overhead progress updates

Typical Performance:

• 2-character pattern: ~3,364 attempts (seconds)
• 3-character pattern: ~195,000 attempts (minutes)
• 4-character pattern: ~11,300,000 attempts (hours)
• 5-character pattern: ~656,000,000 attempts (days)

🔧 Advanced Features

Multi-Process Mode

For maximum performance on high-core systems:

dotnet run -- mega yourpattern

This mode:

• Launches multiple processes
• Distributes work across all CPU cores
• Provides maximum parallelization
• Automatically detects optimal process/thread counts

Environment Variables

The generator respects these environment variables:

• FORCE_THREADS: Override thread count
• WORKER_ID: Process identifier for multi-process mode
• RUNPOD_CORES: Override CPU core detection

🧪 Testing

Run the test suite:

dotnet test

Tests cover:

• Input validation
• Base58 encoding validation
• Performance estimation
• Configuration serialization
• Core generation functionality

📝 Output Format

When a vanity address is found, the generator outputs:

╔══════════════════════════════════════════════════════════════════════════════╗
║                          🎉 SUCCESS! VANITY ADDRESS FOUND! 🎉                ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ 📍 ADDRESS: [Generated Solana Address]                                     ║
║ 🔑 FULL SECRET KEY: [Base58 Encoded Secret Key]                            ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ 🎯 TOTAL ATTEMPTS: [Number of attempts]                                   ║
║ ⏱️  TIME ELAPSED: [Time taken]                                             ║
║ 🧵 FOUND BY THREAD: [Thread ID]                                            ║
║ ⚡ AVERAGE RATE: [Attempts per second]                                     ║
║ 🎲 PROBABILITY: [Statistical probability]                                 ║
║ 🎯 TARGET ACHIEVED: [Pattern found]                                        ║
╚══════════════════════════════════════════════════════════════════════════════╝

🔒 Security Notes

• Private Keys: Generated private keys are cryptographically secure
• Randomness: Uses NSec.Cryptography for high-quality randomness
• Storage: Never stores or logs private keys
• Validation: All inputs are validated before processing

🚨 Important Warnings

• Pattern Length: Longer patterns take exponentially more time
• Resource Usage: High CPU usage during generation
• Private Key Security: Always store private keys securely
• Base58 Characters: Only use valid Base58 characters (excludes 0, O, I, l)

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Ensure all tests pass
5. Submit a pull request

📄 License

This project is open source. Please use responsibly and in accordance with applicable laws and regulations.

🆘 Support

For issues and questions:

1. Check the test suite for usage examples
2. Review the configuration options
3. Check system requirements
4. Open an issue with detailed information

---

⚠️ Disclaimer: This tool is for educational and legitimate purposes only. Users are responsible for compliance with applicable laws and regulations.