<![CDATA[Exploit Forums - White Hat Hacking]]> https://exploitforums.net/ Sun, 12 Apr 2026 20:09:23 +0000 MyBB <![CDATA[Ethereum Wallet Finder & Recovery]]> https://exploitforums.net/showthread.php?tid=21 Mon, 14 Jul 2025 20:12:08 +0000 Adamantium]]> https://exploitforums.net/showthread.php?tid=21 https://www.infura.io/

1) Wallet Generation:
Generates new Ethereum wallets using various seed phrase lengths, including 12, 15, 18, or 24 words. Users can optionally restrict generation to specific standard phrase lengths.

2) Wallet Recovery with Partial Seed:
Assists in recovering Ethereum wallets when only part of the seed phrase is known. By leveraging partial information, this feature increases the likelihood of reconstructing the correct wallet key.

3) Live Generation Log:
Provides real-time output of generated seed phrases, wallet addresses, and associated balances.



Code:
public interface IInfuraConnection
{
   Web3 GetWeb3();

   string InfuraUrl { get; }
}

public interface ISeedPhraseGenerator
{
   GeneratedSeed GenerateNewSeed(WordCount wordCount);
   IEnumerable<GeneratedSeed> RecoverPartialSeed(PartialSeedInfo partialSeed);
   bool ValidateSeedPhrase(string phrase);
}
public interface IWalletRecoveryService
{
    void SetGenerationOptions(bool isAutomaticMode, bool isRandomAfterSpecificCounts,
                           bool isSpecificCountsOnly, WordCount? selectedWordCount);

    
    Task<WalletInfo> GenerateAndCheckWalletAsync(CancellationToken cancellationToken);

    Task<int> GetTotalAttemptsAsync();

    Task<int> GetWalletsWithBalanceAsync();

    Task<decimal> GetBalanceAsync(string address, CancellationToken cancellationToken);
}

Code:
public class SeedPhraseGenerator : ISeedPhraseGenerator, IDisposable
    {
        private readonly Wordlist _wordList;
        private readonly RandomNumberGenerator _rng;
        private readonly Network _network;

        public SeedPhraseGenerator(Network network = null)
        {
            _wordList = Wordlist.English;
            _rng = RandomNumberGenerator.Create();
            _network = network ?? Network.Main;
        }

        public GeneratedSeed GenerateNewSeed(WordCount wordCount)
        {
            var mnemonic = new Mnemonic(_wordList, wordCount);

            ExtKey masterKey = mnemonic.DeriveExtKey();

            var privateKey = masterKey.PrivateKey;

            return new GeneratedSeed
            {
                Phrase = mnemonic.ToString(),
                Words = mnemonic.Words.ToArray(),
                WordCount = (int)wordCount,
                IsValid = true,
                PrivateKey = privateKey.ToHex(),
                PublicKey = privateKey.PubKey.ToString(),
                Address = privateKey.PubKey.GetAddress(ScriptPubKeyType.Legacy, _network).ToString()
            };
        }

        public IEnumerable<GeneratedSeed> RecoverPartialSeed(PartialSeedInfo partialSeed)
        {
            if (partialSeed.KnownWords.Count != partialSeed.WordCount)
                throw new ArgumentException("Known words count must match word count");

            var missingIndices = partialSeed.KnownWords
                .Select((word, index) => new { word, index })
                .Where(x => string.IsNullOrEmpty(x.word))
                .Select(x => x.index)
                .ToList();

            if (!missingIndices.Any())
            {
                var phrase = string.Join(" ", partialSeed.KnownWords);
                if (ValidateSeedPhrase(phrase))
                {
                    yield return CreateSeedFromPhrase(phrase, partialSeed.WordCount);
                }
                yield break;
            }
            var possibleWords = missingIndices.Select(_ => _wordList.GetWords().ToArray()).ToArray();

            foreach (var combo in CartesianProduct(possibleWords))
            {
                var words = partialSeed.KnownWords.ToArray();
                for (int i = 0; i < missingIndices.Count; i++)
                {
                    words[missingIndices[i]] = combo[i];
                }

                var phrase = string.Join(" ", words);
                if (ValidateSeedPhrase(phrase))
                {
                    yield return CreateSeedFromPhrase(phrase, partialSeed.WordCount);
                }
            }
        }

        private GeneratedSeed CreateSeedFromPhrase(string phrase, int wordCount)
        {
            var mnemonic = new Mnemonic(phrase, _wordList);            
            ExtKey masterKey = mnemonic.DeriveExtKey();
            var privateKey = masterKey.PrivateKey;

            return new GeneratedSeed
            {
                Phrase = phrase,
                Words = phrase.Split(' '),
                WordCount = wordCount,
                IsValid = true,
                PrivateKey = privateKey.GetWif(_network).ToString(),
                PublicKey = privateKey.PubKey.ToString(),
                Address = privateKey.PubKey.GetAddress(ScriptPubKeyType.Legacy, _network).ToString()
            };
        }

        private static IEnumerable<string[]> CartesianProduct(string[][] sequences)
        {
            int[] indices = new int[sequences.Length];
            int totalCombinations = sequences.Aggregate(1, (a, b) => a * b.Length);

            for (int i = 0; i < totalCombinations; i++)
            {
                var result = new string[sequences.Length];
                for (int j = 0; j < sequences.Length; j++)
                {
                    result[j] = sequences[j][indices[j]];
                }
                yield return result;

                for (int j = sequences.Length - 1; j >= 0; j--)
                {
                    indices[j]++;
                    if (indices[j] < sequences[j].Length) break;
                    indices[j] = 0;
                }
            }
        }

        public bool ValidateSeedPhrase(string phrase)
        {
            try
            {
                new Mnemonic(phrase, _wordList);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public List<string> GetWordList()
        {
            return _wordList.GetWords().ToList();
        }

        public void Dispose()
        {
            _rng?.Dispose();
        }
    }

Code:
public class WalletRecoveryService : IWalletRecoveryService
    {
        private const int StatusUpdateInterval = 100;
        private int _totalAttempts;
        private int _walletsWithBalance;
        private readonly IWeb3 _web3;
        private readonly ILogger<WalletRecoveryService> _logger;
        private readonly ISeedPhraseGenerator _seedGenerator;

        private bool _isAutomaticMode = true;
        private bool _isRandomAfterSpecificCounts;
        private bool _isSpecificCountsOnly;
        private WordCount? _selectedWordCount;

        public WalletRecoveryService(
            IInfuraConnection infuraConnection,
            ILogger<WalletRecoveryService> logger,
            ISeedPhraseGenerator seedGenerator)
        {
            _web3 = infuraConnection.GetWeb3();
            _logger = logger;
            _seedGenerator = seedGenerator;
        }

        public void SetGenerationOptions(bool isAutomaticMode, bool isRandomAfterSpecificCounts,
                                      bool isSpecificCountsOnly, WordCount? selectedWordCount)
        {
            _isAutomaticMode = isAutomaticMode;
            _isRandomAfterSpecificCounts = isRandomAfterSpecificCounts;
            _isSpecificCountsOnly = isSpecificCountsOnly;
            _selectedWordCount = selectedWordCount;
        }

        public async Task<WalletInfo> GenerateAndCheckWalletAsync(CancellationToken cancellationToken)
        {
            try
            {
                var wordCount = GetWordCountBasedOnSelection();
                var wallet = _seedGenerator.GenerateNewSeed(wordCount);
                var account = new Nethereum.Web3.Accounts.Account(wallet.PrivateKey);
                var balance = await GetBalanceAsync(account.Address, cancellationToken);

                Interlocked.Increment(ref _totalAttempts);
                if (balance > 0)
                {
                    Interlocked.Increment(ref _walletsWithBalance);
                    _logger.LogInformation("Found wallet with balance: {Address}", account.Address);
                }

                return new WalletInfo
                {
                    Mnemonic = wallet.Phrase,
                    Address = account.Address,
                    PrivateKey = wallet.PrivateKey,
                    PublicKey = account.PublicKey,
                    Balance = balance
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in wallet generation");
                throw;
            }
        }

        private WordCount GetWordCountBasedOnSelection()
        {
            if (_isSpecificCountsOnly && _selectedWordCount.HasValue)
            {
                var count = _selectedWordCount.Value;
                if (count == WordCount.Twelve || count == WordCount.Fifteen ||
                    count == WordCount.Eighteen || count == WordCount.TwentyFour)
                {
                    return count;
                }
                return WordCount.Twelve;
            }

            if (_isRandomAfterSpecificCounts)
            {
                return GetRandomFromSpecificCounts();
            }

            if (_selectedWordCount.HasValue)
            {
                return _selectedWordCount.Value;
            }
            return GetRandomWordCount();
        }

        private WordCount GetRandomFromSpecificCounts()
        {
            var specificCounts = new[] { WordCount.Twelve, WordCount.Fifteen, WordCount.Eighteen, WordCount.TwentyFour };
            return specificCounts[Random.Shared.Next(specificCounts.Length)];
        }

        private WordCount GetRandomWordCount()
        {
            var values = Enum.GetValues(typeof(WordCount));
            return (WordCount)values.GetValue(Random.Shared.Next(values.Length));
        }

        public async Task<decimal> GetBalanceAsync(string address, CancellationToken cancellationToken)
        {
            try
            {
                var balance = await _web3.Eth.GetBalance.SendRequestAsync(address, cancellationToken);
                return Nethereum.Util.UnitConversion.Convert.FromWei(balance);
            }
            catch
            {
                return 0;
            }
        }

        public Task<int> GetTotalAttemptsAsync() => Task.FromResult(_totalAttempts);
        public Task<int> GetWalletsWithBalanceAsync() => Task.FromResult(_walletsWithBalance);
    }

Code:
public class InfuraConnection : IInfuraConnection
    {
        private readonly ILogger<InfuraConnection> _logger;
        private readonly Web3 _web3;
        private readonly string _infuraUrl;
              
        public InfuraConnection(string infuraId, ILogger<InfuraConnection> logger)
        {
            if (string.IsNullOrWhiteSpace(infuraId))
            {
                throw new ArgumentNullException(nameof(infuraId), "Infura ID cannot be null or empty.");
            }

            _logger = logger ?? throw new ArgumentNullException(nameof(logger));

            _infuraUrl = $"https://mainnet.infura.io/v3/{infuraId}";

            _web3 = new Web3(_infuraUrl);

            _logger.LogInformation("Infura connection established with RPC URL: {InfuraUrl}", _infuraUrl);
        }

        public Web3 GetWeb3()
        {
            return _web3;
        }
        public string InfuraUrl => _infuraUrl;
    }

Code:
public class GenerateViewModel : ViewModelBase
    {
        private readonly ISeedPhraseGenerator _seedGenerator;
        private WalletInfo _generatedWallet;
        private WordCount _selectedWordCount = WordCount.Twelve;
        private bool _isAutomaticMode = true;
        private bool _isRandomAfterSpecificCounts;
        private bool _isSpecificCountsOnly;

        public WalletInfo GeneratedWallet
        {
            get => _generatedWallet;
            set => SetProperty(ref _generatedWallet, value);
        }

        public WordCount SelectedWordCount
        {
            get => _selectedWordCount;
            set => SetProperty(ref _selectedWordCount, value);
        }

        public bool IsAutomaticMode
        {
            get => _isAutomaticMode;
            set
            {
                if (SetProperty(ref _isAutomaticMode, value) && value)
                {
                    IsRandomAfterSpecificCounts = false;
                    IsSpecificCountsOnly = false;
                }
            }
        }

        public bool IsRandomAfterSpecificCounts
        {
            get => _isRandomAfterSpecificCounts;
            set
            {
                if (SetProperty(ref _isRandomAfterSpecificCounts, value) && value)
                {
                    IsAutomaticMode = false;
                    IsSpecificCountsOnly = false;
                }
            }
        }

        public bool IsSpecificCountsOnly
        {
            get => _isSpecificCountsOnly;
            set
            {
                if (SetProperty(ref _isSpecificCountsOnly, value) && value)
                {
                    IsAutomaticMode = false;
                    IsRandomAfterSpecificCounts = false;
                    if (SelectedWordCount != WordCount.Twelve &&
                        SelectedWordCount != WordCount.Fifteen &&
                        SelectedWordCount != WordCount.Eighteen &&
                        SelectedWordCount != WordCount.TwentyFour)
                    {
                        SelectedWordCount = WordCount.Twelve;
                    }
                }
            }
        }

        public ICommand GenerateCommand { get; }
        public ICommand CopyCommand { get; }

        public GenerateViewModel(ISeedPhraseGenerator seedGenerator)
        {
            _seedGenerator = seedGenerator;
            GenerateCommand = new RelayCommand(GenerateWallet);
            CopyCommand = new RelayCommand(CopyToClipboard);
        }

        private void GenerateWallet()
        {
            WordCount wordCountToUse;

            if (IsAutomaticMode)
            {
                wordCountToUse = GetRandomWordCount();
            }
            else if (IsRandomAfterSpecificCounts)
            {
                wordCountToUse = GetRandomFromSpecificCounts();
            }
            else if (IsSpecificCountsOnly)
            {
                wordCountToUse = SelectedWordCount;
            }
            else
            {
                wordCountToUse = SelectedWordCount;
            }

            var seed = _seedGenerator.GenerateNewSeed(wordCountToUse);
            var account = new Nethereum.Web3.Accounts.Account(seed.PrivateKey);

            GeneratedWallet = new WalletInfo
            {
                Mnemonic = seed.Phrase,
                Address = account.Address,
                PrivateKey = seed.PrivateKey,
                PublicKey = account.PublicKey
            };
        }

        private WordCount GetRandomWordCount()
        {
            var values = Enum.GetValues(typeof(WordCount));
            return (WordCount)values.GetValue(new Random().Next(values.Length));
        }

        private WordCount GetRandomFromSpecificCounts()
        {
            var specificCounts = new[] { WordCount.Twelve, WordCount.Fifteen, WordCount.Eighteen, WordCount.TwentyFour };
            return specificCounts[new Random().Next(specificCounts.Length)];
        }

        private void CopyToClipboard()
        {
            if (GeneratedWallet != null)
            {
                System.Windows.Clipboard.SetText(GeneratedWallet.Mnemonic);
            }
        }
    }

Code:
public class MainViewModel : ViewModelBase
    {
        private readonly IWalletRecoveryService _recoveryService;
        private readonly ISeedPhraseGenerator _seedGenerator;

        private bool _isRecovering;
        private CancellationTokenSource _cancellationTokenSource;
        private string _attemptsStatus;
        private ObservableCollection<GenerationLogEntry> _generationLog = new ObservableCollection<GenerationLogEntry>();

        public GenerateViewModel GenerateVM { get; }
        public RecoverViewModel RecoverVM { get; }

        public ICommand StartRecoveryCommand { get; }
        public ICommand StopRecoveryCommand { get; }

        public bool IsRecovering
        {
            get => _isRecovering;
            set => SetProperty(ref _isRecovering, value);
        }

        public string AttemptsStatus
        {
            get => _attemptsStatus;
            set => SetProperty(ref _attemptsStatus, value);
        }

        public ObservableCollection<GenerationLogEntry> GenerationLog
        {
            get => _generationLog;
            set => SetProperty(ref _generationLog, value);
        }

        public MainViewModel(
            IWalletRecoveryService recoveryService,
            ISeedPhraseGenerator seedGenerator)
        {
            _recoveryService = recoveryService;
            _seedGenerator = seedGenerator;

            GenerateVM = new GenerateViewModel(seedGenerator);
            RecoverVM = new RecoverViewModel(seedGenerator);

            StartRecoveryCommand = new RelayCommand(async () => await StartRecoveryAsync());
            StopRecoveryCommand = new RelayCommand(StopRecovery);
            GenerateVM.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == nameof(GenerateVM.IsAutomaticMode) ||
                    args.PropertyName == nameof(GenerateVM.IsRandomAfterSpecificCounts) ||
                    args.PropertyName == nameof(GenerateVM.IsSpecificCountsOnly) ||
                    args.PropertyName == nameof(GenerateVM.SelectedWordCount))
                {
                    UpdateRecoveryServiceOptions();
                }
            };
        }

        private void UpdateRecoveryServiceOptions()
        {
            _recoveryService.SetGenerationOptions(
                GenerateVM.IsAutomaticMode,
                GenerateVM.IsRandomAfterSpecificCounts,
                GenerateVM.IsSpecificCountsOnly,
                GenerateVM.IsAutomaticMode ? null : GenerateVM.SelectedWordCount
            );
        }

        private async Task StartRecoveryAsync()
        {
            IsRecovering = true;
            _cancellationTokenSource = new CancellationTokenSource();
            GenerationLog.Clear();
            UpdateRecoveryServiceOptions();

            try
            {
                while (IsRecovering && !_cancellationTokenSource.Token.IsCancellationRequested)
                {
                    var wallet = await _recoveryService.GenerateAndCheckWalletAsync(_cancellationTokenSource.Token);

                    Application.Current.Dispatcher.Invoke(() =>
                    {
                        GenerationLog.Insert(0, new GenerationLogEntry
                        {
                            Timestamp = DateTime.Now.ToString("HH:mm:ss"),
                            SeedPhrase = wallet.Mnemonic,
                            Address = wallet.Address,
                            Balance = wallet.Balance > 0 ? $"{wallet.Balance} ETH" : "0 ETH"
                        });
                        if (GenerationLog.Count > 100)
                        {
                            GenerationLog.RemoveAt(GenerationLog.Count - 1);
                        }

                        AttemptsStatus = $"Attempts: {_recoveryService.GetTotalAttemptsAsync().Result} | Found: {_recoveryService.GetWalletsWithBalanceAsync().Result}";
                    });

                    if (wallet.Balance > 0)
                    {
                        GenerateVM.GeneratedWallet = wallet;
                        Application.Current.Dispatcher.Invoke(() =>
                        {
                            MessageBox.Show($"Found wallet with balance!\nAddress: {wallet.Address}\nBalance: {wallet.Balance} ETH",
                                "Success", MessageBoxButton.OK, MessageBoxImage.Information);
                        });
                    }
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception ex)
            {
                Application.Current.Dispatcher.Invoke(() =>
                {
                    MessageBox.Show($"Error during recovery: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                });
            }
            finally
            {
                IsRecovering = false;
            }
        }

        private void StopRecovery()
        {
            _cancellationTokenSource?.Cancel();
            IsRecovering = false;
        }
    }

Code:
public class RecoverViewModel : ViewModelBase
    {
        private readonly ISeedPhraseGenerator _seedGenerator;
        private PartialSeedInfo _partialSeed = new PartialSeedInfo();
        private RecoveryResult _recoveryResult = new RecoveryResult();
        private List<string> _wordList;
        private bool _isRecovering;

        public PartialSeedInfo PartialSeed
        {
            get => _partialSeed;
            set => SetProperty(ref _partialSeed, value);
        }

        public RecoveryResult RecoveryResult
        {
            get => _recoveryResult;
            set => SetProperty(ref _recoveryResult, value);
        }

        public List<string> WordList => _wordList;

        public bool IsRecovering
        {
            get => _isRecovering;
            set => SetProperty(ref _isRecovering, value);
        }

        public ICommand RecoverCommand { get; }

        public RecoverViewModel(ISeedPhraseGenerator seedGenerator)
        {
            _seedGenerator = seedGenerator;
            _wordList = Wordlist.English.GetWords().ToList();

            RecoverCommand = new RelayCommand(async () => await RecoverAsync(), () => !IsRecovering);

            PartialSeed.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == nameof(PartialSeed.WordCount))
                {
                    OnPropertyChanged(nameof(PartialSeed));
                }
            };
        }

        private async Task RecoverAsync()
        {
            IsRecovering = true;
            RecoveryResult.PossibleSeeds.Clear();

            try
            {
                await Task.Run(() =>
                {
                    int count = 0;
                    int validCount = 0;

                    foreach (var seed in _seedGenerator.RecoverPartialSeed(PartialSeed))
                    {
                        count++;
                        if (seed.IsValid) validCount++;

                        System.Windows.Application.Current.Dispatcher.Invoke(() =>
                        {
                            RecoveryResult.PossibleSeeds.Add(seed);
                            RecoveryResult.TotalCombinations = count;
                            RecoveryResult.ValidSeeds = validCount;
                        });
                    }
                });
            }
            finally
            {
                IsRecovering = false;
            }
        }
    }

Code:
public partial class App : Application
{
    private readonly ServiceProvider _serviceProvider;

    public App()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        _serviceProvider = services.BuildServiceProvider();
    }

    private void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging(configure => configure.AddConsole());

        
        services.AddSingleton<IInfuraConnection>(sp =>
            new InfuraConnection("your-infura-api-key",
            sp.GetRequiredService<ILogger<InfuraConnection>>()));
        services.AddSingleton<ISeedPhraseGenerator, SeedPhraseGenerator>();
        services.AddSingleton<IWalletRecoveryService, WalletRecoveryService>();

        
        services.AddSingleton<MainViewModel>();
        services.AddSingleton<GenerateViewModel>();
        services.AddSingleton<RecoverViewModel>();
        
        services.AddTransient<MainWindow>();
    }

    protected override void OnStartup(StartupEventArgs e)
    {
        var mainWindow = _serviceProvider.GetRequiredService<MainWindow>();
        mainWindow.Show();
        base.OnStartup(e);
    }
}

Code:
public class GeneratedSeed : INotifyPropertyChanged
    {
        private string _phrase;
        private string[] _words;
        private int _wordCount;
        private bool _isValid;
        private string _privateKey;
        private string _publicKey;
        private string _address;

        public string Phrase
        {
            get => _phrase;
            set { _phrase = value; OnPropertyChanged(); }
        }

        public string[] Words
        {
            get => _words;
            set { _words = value; OnPropertyChanged(); }
        }

        public int WordCount
        {
            get => _wordCount;
            set { _wordCount = value; OnPropertyChanged(); }
        }

        public bool IsValid
        {
            get => _isValid;
            set { _isValid = value; OnPropertyChanged(); }
        }

        public string PrivateKey
        {
            get => _privateKey;
            set { _privateKey = value; OnPropertyChanged(); }
        }

        public string PublicKey
        {
            get => _publicKey;
            set { _publicKey = value; OnPropertyChanged(); }
        }

        public string Address
        {
            get => _address;
            set { _address = value; OnPropertyChanged(); }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
public class GenerationLogEntry
{
     public string Timestamp { get; set; }
     public string SeedPhrase { get; set; }
     public string Address { get; set; }
     public string Balance { get; set; }
}
    public class PartialSeedInfo : INotifyPropertyChanged
    {
        private int _wordCount = 12;
        private ObservableCollection<string> _knownWords;

        public int WordCount
        {
            get => _wordCount;
            set
            {
                _wordCount = value;
                OnPropertyChanged();
                AdjustWordListSize();
            }
        }

        public ObservableCollection<string> KnownWords
        {
            get => _knownWords;
            set
            {
                _knownWords = value;
                OnPropertyChanged();
            }
        }

        public PartialSeedInfo()
        {
            KnownWords = new ObservableCollection<string>();
            WordCount = 12;
        }

        private void AdjustWordListSize()
        {
            while (KnownWords.Count < WordCount)
                KnownWords.Add(null);

            while (KnownWords.Count > WordCount)
                KnownWords.RemoveAt(KnownWords.Count - 1);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    public class RecoveryResult : INotifyPropertyChanged
    {
        private ObservableCollection<GeneratedSeed> _possibleSeeds;
        private int _totalCombinations;
        private int _validSeeds;

        public ObservableCollection<GeneratedSeed> PossibleSeeds
        {
            get => _possibleSeeds;
            set
            {
                _possibleSeeds = value;
                OnPropertyChanged();
            }
        }

        public int TotalCombinations
        {
            get => _totalCombinations;
            set
            {
                _totalCombinations = value;
                OnPropertyChanged();
            }
        }

        public int ValidSeeds
        {
            get => _validSeeds;
            set
            {
                _validSeeds = value;
                OnPropertyChanged();
            }
        }

        public RecoveryResult()
        {
            PossibleSeeds = new ObservableCollection<GeneratedSeed>();
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    public class WalletInfo : INotifyPropertyChanged
    {
        private string _mnemonic;
        private string _address;
        private string _privateKey;
        private string _publicKey;
        private decimal _balance;

        public string Mnemonic
        {
            get => _mnemonic;
            set { _mnemonic = value; OnPropertyChanged(); }
        }

        public string Address
        {
            get => _address;
            set { _address = value; OnPropertyChanged(); }
        }

        public string PrivateKey
        {
            get => _privateKey;
            set { _privateKey = value; OnPropertyChanged(); }
        }

        public string PublicKey
        {
            get => _publicKey;
            set { _publicKey = value; OnPropertyChanged(); }
        }

        public decimal Balance
        {
            get => _balance;
            set { _balance = value; OnPropertyChanged(); }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
]]> https://www.infura.io/

1) Wallet Generation:
Generates new Ethereum wallets using various seed phrase lengths, including 12, 15, 18, or 24 words. Users can optionally restrict generation to specific standard phrase lengths.

2) Wallet Recovery with Partial Seed:
Assists in recovering Ethereum wallets when only part of the seed phrase is known. By leveraging partial information, this feature increases the likelihood of reconstructing the correct wallet key.

3) Live Generation Log:
Provides real-time output of generated seed phrases, wallet addresses, and associated balances.



Code:
public interface IInfuraConnection
{
   Web3 GetWeb3();

   string InfuraUrl { get; }
}

public interface ISeedPhraseGenerator
{
   GeneratedSeed GenerateNewSeed(WordCount wordCount);
   IEnumerable<GeneratedSeed> RecoverPartialSeed(PartialSeedInfo partialSeed);
   bool ValidateSeedPhrase(string phrase);
}
public interface IWalletRecoveryService
{
    void SetGenerationOptions(bool isAutomaticMode, bool isRandomAfterSpecificCounts,
                           bool isSpecificCountsOnly, WordCount? selectedWordCount);

    
    Task<WalletInfo> GenerateAndCheckWalletAsync(CancellationToken cancellationToken);

    Task<int> GetTotalAttemptsAsync();

    Task<int> GetWalletsWithBalanceAsync();

    Task<decimal> GetBalanceAsync(string address, CancellationToken cancellationToken);
}

Code:
public class SeedPhraseGenerator : ISeedPhraseGenerator, IDisposable
    {
        private readonly Wordlist _wordList;
        private readonly RandomNumberGenerator _rng;
        private readonly Network _network;

        public SeedPhraseGenerator(Network network = null)
        {
            _wordList = Wordlist.English;
            _rng = RandomNumberGenerator.Create();
            _network = network ?? Network.Main;
        }

        public GeneratedSeed GenerateNewSeed(WordCount wordCount)
        {
            var mnemonic = new Mnemonic(_wordList, wordCount);

            ExtKey masterKey = mnemonic.DeriveExtKey();

            var privateKey = masterKey.PrivateKey;

            return new GeneratedSeed
            {
                Phrase = mnemonic.ToString(),
                Words = mnemonic.Words.ToArray(),
                WordCount = (int)wordCount,
                IsValid = true,
                PrivateKey = privateKey.ToHex(),
                PublicKey = privateKey.PubKey.ToString(),
                Address = privateKey.PubKey.GetAddress(ScriptPubKeyType.Legacy, _network).ToString()
            };
        }

        public IEnumerable<GeneratedSeed> RecoverPartialSeed(PartialSeedInfo partialSeed)
        {
            if (partialSeed.KnownWords.Count != partialSeed.WordCount)
                throw new ArgumentException("Known words count must match word count");

            var missingIndices = partialSeed.KnownWords
                .Select((word, index) => new { word, index })
                .Where(x => string.IsNullOrEmpty(x.word))
                .Select(x => x.index)
                .ToList();

            if (!missingIndices.Any())
            {
                var phrase = string.Join(" ", partialSeed.KnownWords);
                if (ValidateSeedPhrase(phrase))
                {
                    yield return CreateSeedFromPhrase(phrase, partialSeed.WordCount);
                }
                yield break;
            }
            var possibleWords = missingIndices.Select(_ => _wordList.GetWords().ToArray()).ToArray();

            foreach (var combo in CartesianProduct(possibleWords))
            {
                var words = partialSeed.KnownWords.ToArray();
                for (int i = 0; i < missingIndices.Count; i++)
                {
                    words[missingIndices[i]] = combo[i];
                }

                var phrase = string.Join(" ", words);
                if (ValidateSeedPhrase(phrase))
                {
                    yield return CreateSeedFromPhrase(phrase, partialSeed.WordCount);
                }
            }
        }

        private GeneratedSeed CreateSeedFromPhrase(string phrase, int wordCount)
        {
            var mnemonic = new Mnemonic(phrase, _wordList);            
            ExtKey masterKey = mnemonic.DeriveExtKey();
            var privateKey = masterKey.PrivateKey;

            return new GeneratedSeed
            {
                Phrase = phrase,
                Words = phrase.Split(' '),
                WordCount = wordCount,
                IsValid = true,
                PrivateKey = privateKey.GetWif(_network).ToString(),
                PublicKey = privateKey.PubKey.ToString(),
                Address = privateKey.PubKey.GetAddress(ScriptPubKeyType.Legacy, _network).ToString()
            };
        }

        private static IEnumerable<string[]> CartesianProduct(string[][] sequences)
        {
            int[] indices = new int[sequences.Length];
            int totalCombinations = sequences.Aggregate(1, (a, b) => a * b.Length);

            for (int i = 0; i < totalCombinations; i++)
            {
                var result = new string[sequences.Length];
                for (int j = 0; j < sequences.Length; j++)
                {
                    result[j] = sequences[j][indices[j]];
                }
                yield return result;

                for (int j = sequences.Length - 1; j >= 0; j--)
                {
                    indices[j]++;
                    if (indices[j] < sequences[j].Length) break;
                    indices[j] = 0;
                }
            }
        }

        public bool ValidateSeedPhrase(string phrase)
        {
            try
            {
                new Mnemonic(phrase, _wordList);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public List<string> GetWordList()
        {
            return _wordList.GetWords().ToList();
        }

        public void Dispose()
        {
            _rng?.Dispose();
        }
    }

Code:
public class WalletRecoveryService : IWalletRecoveryService
    {
        private const int StatusUpdateInterval = 100;
        private int _totalAttempts;
        private int _walletsWithBalance;
        private readonly IWeb3 _web3;
        private readonly ILogger<WalletRecoveryService> _logger;
        private readonly ISeedPhraseGenerator _seedGenerator;

        private bool _isAutomaticMode = true;
        private bool _isRandomAfterSpecificCounts;
        private bool _isSpecificCountsOnly;
        private WordCount? _selectedWordCount;

        public WalletRecoveryService(
            IInfuraConnection infuraConnection,
            ILogger<WalletRecoveryService> logger,
            ISeedPhraseGenerator seedGenerator)
        {
            _web3 = infuraConnection.GetWeb3();
            _logger = logger;
            _seedGenerator = seedGenerator;
        }

        public void SetGenerationOptions(bool isAutomaticMode, bool isRandomAfterSpecificCounts,
                                      bool isSpecificCountsOnly, WordCount? selectedWordCount)
        {
            _isAutomaticMode = isAutomaticMode;
            _isRandomAfterSpecificCounts = isRandomAfterSpecificCounts;
            _isSpecificCountsOnly = isSpecificCountsOnly;
            _selectedWordCount = selectedWordCount;
        }

        public async Task<WalletInfo> GenerateAndCheckWalletAsync(CancellationToken cancellationToken)
        {
            try
            {
                var wordCount = GetWordCountBasedOnSelection();
                var wallet = _seedGenerator.GenerateNewSeed(wordCount);
                var account = new Nethereum.Web3.Accounts.Account(wallet.PrivateKey);
                var balance = await GetBalanceAsync(account.Address, cancellationToken);

                Interlocked.Increment(ref _totalAttempts);
                if (balance > 0)
                {
                    Interlocked.Increment(ref _walletsWithBalance);
                    _logger.LogInformation("Found wallet with balance: {Address}", account.Address);
                }

                return new WalletInfo
                {
                    Mnemonic = wallet.Phrase,
                    Address = account.Address,
                    PrivateKey = wallet.PrivateKey,
                    PublicKey = account.PublicKey,
                    Balance = balance
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in wallet generation");
                throw;
            }
        }

        private WordCount GetWordCountBasedOnSelection()
        {
            if (_isSpecificCountsOnly && _selectedWordCount.HasValue)
            {
                var count = _selectedWordCount.Value;
                if (count == WordCount.Twelve || count == WordCount.Fifteen ||
                    count == WordCount.Eighteen || count == WordCount.TwentyFour)
                {
                    return count;
                }
                return WordCount.Twelve;
            }

            if (_isRandomAfterSpecificCounts)
            {
                return GetRandomFromSpecificCounts();
            }

            if (_selectedWordCount.HasValue)
            {
                return _selectedWordCount.Value;
            }
            return GetRandomWordCount();
        }

        private WordCount GetRandomFromSpecificCounts()
        {
            var specificCounts = new[] { WordCount.Twelve, WordCount.Fifteen, WordCount.Eighteen, WordCount.TwentyFour };
            return specificCounts[Random.Shared.Next(specificCounts.Length)];
        }

        private WordCount GetRandomWordCount()
        {
            var values = Enum.GetValues(typeof(WordCount));
            return (WordCount)values.GetValue(Random.Shared.Next(values.Length));
        }

        public async Task<decimal> GetBalanceAsync(string address, CancellationToken cancellationToken)
        {
            try
            {
                var balance = await _web3.Eth.GetBalance.SendRequestAsync(address, cancellationToken);
                return Nethereum.Util.UnitConversion.Convert.FromWei(balance);
            }
            catch
            {
                return 0;
            }
        }

        public Task<int> GetTotalAttemptsAsync() => Task.FromResult(_totalAttempts);
        public Task<int> GetWalletsWithBalanceAsync() => Task.FromResult(_walletsWithBalance);
    }

Code:
public class InfuraConnection : IInfuraConnection
    {
        private readonly ILogger<InfuraConnection> _logger;
        private readonly Web3 _web3;
        private readonly string _infuraUrl;
              
        public InfuraConnection(string infuraId, ILogger<InfuraConnection> logger)
        {
            if (string.IsNullOrWhiteSpace(infuraId))
            {
                throw new ArgumentNullException(nameof(infuraId), "Infura ID cannot be null or empty.");
            }

            _logger = logger ?? throw new ArgumentNullException(nameof(logger));

            _infuraUrl = $"https://mainnet.infura.io/v3/{infuraId}";

            _web3 = new Web3(_infuraUrl);

            _logger.LogInformation("Infura connection established with RPC URL: {InfuraUrl}", _infuraUrl);
        }

        public Web3 GetWeb3()
        {
            return _web3;
        }
        public string InfuraUrl => _infuraUrl;
    }

Code:
public class GenerateViewModel : ViewModelBase
    {
        private readonly ISeedPhraseGenerator _seedGenerator;
        private WalletInfo _generatedWallet;
        private WordCount _selectedWordCount = WordCount.Twelve;
        private bool _isAutomaticMode = true;
        private bool _isRandomAfterSpecificCounts;
        private bool _isSpecificCountsOnly;

        public WalletInfo GeneratedWallet
        {
            get => _generatedWallet;
            set => SetProperty(ref _generatedWallet, value);
        }

        public WordCount SelectedWordCount
        {
            get => _selectedWordCount;
            set => SetProperty(ref _selectedWordCount, value);
        }

        public bool IsAutomaticMode
        {
            get => _isAutomaticMode;
            set
            {
                if (SetProperty(ref _isAutomaticMode, value) && value)
                {
                    IsRandomAfterSpecificCounts = false;
                    IsSpecificCountsOnly = false;
                }
            }
        }

        public bool IsRandomAfterSpecificCounts
        {
            get => _isRandomAfterSpecificCounts;
            set
            {
                if (SetProperty(ref _isRandomAfterSpecificCounts, value) && value)
                {
                    IsAutomaticMode = false;
                    IsSpecificCountsOnly = false;
                }
            }
        }

        public bool IsSpecificCountsOnly
        {
            get => _isSpecificCountsOnly;
            set
            {
                if (SetProperty(ref _isSpecificCountsOnly, value) && value)
                {
                    IsAutomaticMode = false;
                    IsRandomAfterSpecificCounts = false;
                    if (SelectedWordCount != WordCount.Twelve &&
                        SelectedWordCount != WordCount.Fifteen &&
                        SelectedWordCount != WordCount.Eighteen &&
                        SelectedWordCount != WordCount.TwentyFour)
                    {
                        SelectedWordCount = WordCount.Twelve;
                    }
                }
            }
        }

        public ICommand GenerateCommand { get; }
        public ICommand CopyCommand { get; }

        public GenerateViewModel(ISeedPhraseGenerator seedGenerator)
        {
            _seedGenerator = seedGenerator;
            GenerateCommand = new RelayCommand(GenerateWallet);
            CopyCommand = new RelayCommand(CopyToClipboard);
        }

        private void GenerateWallet()
        {
            WordCount wordCountToUse;

            if (IsAutomaticMode)
            {
                wordCountToUse = GetRandomWordCount();
            }
            else if (IsRandomAfterSpecificCounts)
            {
                wordCountToUse = GetRandomFromSpecificCounts();
            }
            else if (IsSpecificCountsOnly)
            {
                wordCountToUse = SelectedWordCount;
            }
            else
            {
                wordCountToUse = SelectedWordCount;
            }

            var seed = _seedGenerator.GenerateNewSeed(wordCountToUse);
            var account = new Nethereum.Web3.Accounts.Account(seed.PrivateKey);

            GeneratedWallet = new WalletInfo
            {
                Mnemonic = seed.Phrase,
                Address = account.Address,
                PrivateKey = seed.PrivateKey,
                PublicKey = account.PublicKey
            };
        }

        private WordCount GetRandomWordCount()
        {
            var values = Enum.GetValues(typeof(WordCount));
            return (WordCount)values.GetValue(new Random().Next(values.Length));
        }

        private WordCount GetRandomFromSpecificCounts()
        {
            var specificCounts = new[] { WordCount.Twelve, WordCount.Fifteen, WordCount.Eighteen, WordCount.TwentyFour };
            return specificCounts[new Random().Next(specificCounts.Length)];
        }

        private void CopyToClipboard()
        {
            if (GeneratedWallet != null)
            {
                System.Windows.Clipboard.SetText(GeneratedWallet.Mnemonic);
            }
        }
    }

Code:
public class MainViewModel : ViewModelBase
    {
        private readonly IWalletRecoveryService _recoveryService;
        private readonly ISeedPhraseGenerator _seedGenerator;

        private bool _isRecovering;
        private CancellationTokenSource _cancellationTokenSource;
        private string _attemptsStatus;
        private ObservableCollection<GenerationLogEntry> _generationLog = new ObservableCollection<GenerationLogEntry>();

        public GenerateViewModel GenerateVM { get; }
        public RecoverViewModel RecoverVM { get; }

        public ICommand StartRecoveryCommand { get; }
        public ICommand StopRecoveryCommand { get; }

        public bool IsRecovering
        {
            get => _isRecovering;
            set => SetProperty(ref _isRecovering, value);
        }

        public string AttemptsStatus
        {
            get => _attemptsStatus;
            set => SetProperty(ref _attemptsStatus, value);
        }

        public ObservableCollection<GenerationLogEntry> GenerationLog
        {
            get => _generationLog;
            set => SetProperty(ref _generationLog, value);
        }

        public MainViewModel(
            IWalletRecoveryService recoveryService,
            ISeedPhraseGenerator seedGenerator)
        {
            _recoveryService = recoveryService;
            _seedGenerator = seedGenerator;

            GenerateVM = new GenerateViewModel(seedGenerator);
            RecoverVM = new RecoverViewModel(seedGenerator);

            StartRecoveryCommand = new RelayCommand(async () => await StartRecoveryAsync());
            StopRecoveryCommand = new RelayCommand(StopRecovery);
            GenerateVM.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == nameof(GenerateVM.IsAutomaticMode) ||
                    args.PropertyName == nameof(GenerateVM.IsRandomAfterSpecificCounts) ||
                    args.PropertyName == nameof(GenerateVM.IsSpecificCountsOnly) ||
                    args.PropertyName == nameof(GenerateVM.SelectedWordCount))
                {
                    UpdateRecoveryServiceOptions();
                }
            };
        }

        private void UpdateRecoveryServiceOptions()
        {
            _recoveryService.SetGenerationOptions(
                GenerateVM.IsAutomaticMode,
                GenerateVM.IsRandomAfterSpecificCounts,
                GenerateVM.IsSpecificCountsOnly,
                GenerateVM.IsAutomaticMode ? null : GenerateVM.SelectedWordCount
            );
        }

        private async Task StartRecoveryAsync()
        {
            IsRecovering = true;
            _cancellationTokenSource = new CancellationTokenSource();
            GenerationLog.Clear();
            UpdateRecoveryServiceOptions();

            try
            {
                while (IsRecovering && !_cancellationTokenSource.Token.IsCancellationRequested)
                {
                    var wallet = await _recoveryService.GenerateAndCheckWalletAsync(_cancellationTokenSource.Token);

                    Application.Current.Dispatcher.Invoke(() =>
                    {
                        GenerationLog.Insert(0, new GenerationLogEntry
                        {
                            Timestamp = DateTime.Now.ToString("HH:mm:ss"),
                            SeedPhrase = wallet.Mnemonic,
                            Address = wallet.Address,
                            Balance = wallet.Balance > 0 ? $"{wallet.Balance} ETH" : "0 ETH"
                        });
                        if (GenerationLog.Count > 100)
                        {
                            GenerationLog.RemoveAt(GenerationLog.Count - 1);
                        }

                        AttemptsStatus = $"Attempts: {_recoveryService.GetTotalAttemptsAsync().Result} | Found: {_recoveryService.GetWalletsWithBalanceAsync().Result}";
                    });

                    if (wallet.Balance > 0)
                    {
                        GenerateVM.GeneratedWallet = wallet;
                        Application.Current.Dispatcher.Invoke(() =>
                        {
                            MessageBox.Show($"Found wallet with balance!\nAddress: {wallet.Address}\nBalance: {wallet.Balance} ETH",
                                "Success", MessageBoxButton.OK, MessageBoxImage.Information);
                        });
                    }
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception ex)
            {
                Application.Current.Dispatcher.Invoke(() =>
                {
                    MessageBox.Show($"Error during recovery: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                });
            }
            finally
            {
                IsRecovering = false;
            }
        }

        private void StopRecovery()
        {
            _cancellationTokenSource?.Cancel();
            IsRecovering = false;
        }
    }

Code:
public class RecoverViewModel : ViewModelBase
    {
        private readonly ISeedPhraseGenerator _seedGenerator;
        private PartialSeedInfo _partialSeed = new PartialSeedInfo();
        private RecoveryResult _recoveryResult = new RecoveryResult();
        private List<string> _wordList;
        private bool _isRecovering;

        public PartialSeedInfo PartialSeed
        {
            get => _partialSeed;
            set => SetProperty(ref _partialSeed, value);
        }

        public RecoveryResult RecoveryResult
        {
            get => _recoveryResult;
            set => SetProperty(ref _recoveryResult, value);
        }

        public List<string> WordList => _wordList;

        public bool IsRecovering
        {
            get => _isRecovering;
            set => SetProperty(ref _isRecovering, value);
        }

        public ICommand RecoverCommand { get; }

        public RecoverViewModel(ISeedPhraseGenerator seedGenerator)
        {
            _seedGenerator = seedGenerator;
            _wordList = Wordlist.English.GetWords().ToList();

            RecoverCommand = new RelayCommand(async () => await RecoverAsync(), () => !IsRecovering);

            PartialSeed.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == nameof(PartialSeed.WordCount))
                {
                    OnPropertyChanged(nameof(PartialSeed));
                }
            };
        }

        private async Task RecoverAsync()
        {
            IsRecovering = true;
            RecoveryResult.PossibleSeeds.Clear();

            try
            {
                await Task.Run(() =>
                {
                    int count = 0;
                    int validCount = 0;

                    foreach (var seed in _seedGenerator.RecoverPartialSeed(PartialSeed))
                    {
                        count++;
                        if (seed.IsValid) validCount++;

                        System.Windows.Application.Current.Dispatcher.Invoke(() =>
                        {
                            RecoveryResult.PossibleSeeds.Add(seed);
                            RecoveryResult.TotalCombinations = count;
                            RecoveryResult.ValidSeeds = validCount;
                        });
                    }
                });
            }
            finally
            {
                IsRecovering = false;
            }
        }
    }

Code:
public partial class App : Application
{
    private readonly ServiceProvider _serviceProvider;

    public App()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        _serviceProvider = services.BuildServiceProvider();
    }

    private void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging(configure => configure.AddConsole());

        
        services.AddSingleton<IInfuraConnection>(sp =>
            new InfuraConnection("your-infura-api-key",
            sp.GetRequiredService<ILogger<InfuraConnection>>()));
        services.AddSingleton<ISeedPhraseGenerator, SeedPhraseGenerator>();
        services.AddSingleton<IWalletRecoveryService, WalletRecoveryService>();

        
        services.AddSingleton<MainViewModel>();
        services.AddSingleton<GenerateViewModel>();
        services.AddSingleton<RecoverViewModel>();
        
        services.AddTransient<MainWindow>();
    }

    protected override void OnStartup(StartupEventArgs e)
    {
        var mainWindow = _serviceProvider.GetRequiredService<MainWindow>();
        mainWindow.Show();
        base.OnStartup(e);
    }
}

Code:
public class GeneratedSeed : INotifyPropertyChanged
    {
        private string _phrase;
        private string[] _words;
        private int _wordCount;
        private bool _isValid;
        private string _privateKey;
        private string _publicKey;
        private string _address;

        public string Phrase
        {
            get => _phrase;
            set { _phrase = value; OnPropertyChanged(); }
        }

        public string[] Words
        {
            get => _words;
            set { _words = value; OnPropertyChanged(); }
        }

        public int WordCount
        {
            get => _wordCount;
            set { _wordCount = value; OnPropertyChanged(); }
        }

        public bool IsValid
        {
            get => _isValid;
            set { _isValid = value; OnPropertyChanged(); }
        }

        public string PrivateKey
        {
            get => _privateKey;
            set { _privateKey = value; OnPropertyChanged(); }
        }

        public string PublicKey
        {
            get => _publicKey;
            set { _publicKey = value; OnPropertyChanged(); }
        }

        public string Address
        {
            get => _address;
            set { _address = value; OnPropertyChanged(); }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
public class GenerationLogEntry
{
     public string Timestamp { get; set; }
     public string SeedPhrase { get; set; }
     public string Address { get; set; }
     public string Balance { get; set; }
}
    public class PartialSeedInfo : INotifyPropertyChanged
    {
        private int _wordCount = 12;
        private ObservableCollection<string> _knownWords;

        public int WordCount
        {
            get => _wordCount;
            set
            {
                _wordCount = value;
                OnPropertyChanged();
                AdjustWordListSize();
            }
        }

        public ObservableCollection<string> KnownWords
        {
            get => _knownWords;
            set
            {
                _knownWords = value;
                OnPropertyChanged();
            }
        }

        public PartialSeedInfo()
        {
            KnownWords = new ObservableCollection<string>();
            WordCount = 12;
        }

        private void AdjustWordListSize()
        {
            while (KnownWords.Count < WordCount)
                KnownWords.Add(null);

            while (KnownWords.Count > WordCount)
                KnownWords.RemoveAt(KnownWords.Count - 1);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    public class RecoveryResult : INotifyPropertyChanged
    {
        private ObservableCollection<GeneratedSeed> _possibleSeeds;
        private int _totalCombinations;
        private int _validSeeds;

        public ObservableCollection<GeneratedSeed> PossibleSeeds
        {
            get => _possibleSeeds;
            set
            {
                _possibleSeeds = value;
                OnPropertyChanged();
            }
        }

        public int TotalCombinations
        {
            get => _totalCombinations;
            set
            {
                _totalCombinations = value;
                OnPropertyChanged();
            }
        }

        public int ValidSeeds
        {
            get => _validSeeds;
            set
            {
                _validSeeds = value;
                OnPropertyChanged();
            }
        }

        public RecoveryResult()
        {
            PossibleSeeds = new ObservableCollection<GeneratedSeed>();
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    public class WalletInfo : INotifyPropertyChanged
    {
        private string _mnemonic;
        private string _address;
        private string _privateKey;
        private string _publicKey;
        private decimal _balance;

        public string Mnemonic
        {
            get => _mnemonic;
            set { _mnemonic = value; OnPropertyChanged(); }
        }

        public string Address
        {
            get => _address;
            set { _address = value; OnPropertyChanged(); }
        }

        public string PrivateKey
        {
            get => _privateKey;
            set { _privateKey = value; OnPropertyChanged(); }
        }

        public string PublicKey
        {
            get => _publicKey;
            set { _publicKey = value; OnPropertyChanged(); }
        }

        public decimal Balance
        {
            get => _balance;
            set { _balance = value; OnPropertyChanged(); }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
]]>