private async Task ManageStakePoolsActionAsync()
        {
            var prevConfiguredStakepoolCount = ConfiguredStakePools.Count;

            // Open dialog that downloads stakepool listing and lets user enter their api key.
            var shell  = (ShellViewModel)ViewModelLocator.ShellViewModel;
            var dialog = new ManageStakePoolsDialogViewModel(shell);

            shell.ShowDialog(dialog);
            await dialog.NotifyCompletionSource.Task; // Wait until dialog is hidden

            await App.Current.Dispatcher.InvokeAsync(() =>
            {
                foreach (var configuredPool in dialog.ConfiguredPools)
                {
                    var poolInfo       = configuredPool.Item1;
                    var poolUserConfig = configuredPool.Item2;

                    if (!ConfiguredStakePools.OfType <StakePoolSelection>().Where(p => p.PoolInfo.Uri.Host == poolInfo.Uri.Host).Any())
                    {
                        var stakePoolSelection = new StakePoolSelection(poolInfo, poolUserConfig.ApiKey,
                                                                        Hexadecimal.Decode(poolUserConfig.MultisigVoteScript));
                        ConfiguredStakePools.Add(stakePoolSelection);
                        RaisePropertyChanged(nameof(VotePreferencesVisibility));
                        SelectedStakePool = stakePoolSelection;
                    }
                }
            });

            if (prevConfiguredStakepoolCount != ConfiguredStakePools.Count)
            {
                await UpdateStakepoolVotePreferences();
            }
        }
        public async Task RunActivityAsync()
        {
            var poolListing = await PoolListApi.QueryStakePoolInfoAsync(_httpClient, _jsonSerializer);

            AvailablePools.AddRange(poolListing
                                    .Select(p => p.Value)
                                    .Where(p => p.ApiEnabled)
                                    .Where(p => p.Uri.Scheme == "https")
                                    .Where(p => p.Network == App.Current.ActiveNetwork.Name)
                                    .Where(p => p.SupportedApiVersions.Where(PoolApiClient.IsSupportedApiVersion).Any())
                                    .OrderBy(p => p.Uri.Host));

            if (File.Exists(_configPath))
            {
                var config = await ReadConfig(_configPath);

                await App.Current.Dispatcher.InvokeAsync(() =>
                {
                    foreach (var entry in config.Entries)
                    {
                        var entryInfo = AvailablePools.Where(p => p.Uri.Host == entry.Host).FirstOrDefault();
                        if (entryInfo == null)
                        {
                            continue;
                        }
                        var stakePoolSelection = new StakePoolSelection(entryInfo, entry.ApiKey, Hexadecimal.Decode(entry.MultisigVoteScript));
                        ConfiguredStakePools.Add(stakePoolSelection);
                        RaisePropertyChanged(nameof(VotePreferencesVisibility));

                        // If only one pool is saved, use this as the default.
                        if (config.Entries.Length == 1)
                        {
                            SelectedStakePool = stakePoolSelection;
                        }
                    }
                });
            }

            await App.Current.Dispatcher.InvokeAsync(() =>
            {
                ManageStakePools.Executable = true;
                CommandManager.InvalidateRequerySuggested();
            });
        }