public NavBarViewModel(TargettedNavigationStack mainScreen, WalletManagerViewModel walletManager)
{
_walletManager = walletManager;
_topItems = new ObservableCollection <NavBarItemViewModel>();
_bottomItems = new ObservableCollection <NavBarItemViewModel>();
mainScreen.WhenAnyValue(x => x.CurrentPage)
.OfType <NavBarItemViewModel>()
.Subscribe(x => CurrentPageChanged(x, walletManager));
this.WhenAnyValue(x => x.SelectedItem)
.OfType <NavBarItemViewModel>()
.Subscribe(NavigateItem);
this.WhenAnyValue(x => x.Items.Count)
.Subscribe(x =>
{
if (x > 0 && SelectedItem is null)
{
SelectedItem = Items.FirstOrDefault();
}
});
this.WhenAnyValue(x => x.IsOpen)
.Subscribe(x =>
{
if (SelectedItem is { })
{
SelectedItem.IsExpanded = x;
}
});
public ConnectHardwareWalletViewModel(string walletName, WalletManagerViewModel walletManagerViewModel)
{
_message = "";
WalletName = walletName;
WalletManager = walletManagerViewModel.Model;
Wallets = walletManagerViewModel.Wallets;
AbandonedTasks = new AbandonedTasks();
CancelCts = new CancellationTokenSource();
NextCommand = ReactiveCommand.Create(() =>
{
if (DetectedDevice is { } device)
{
NavigateToNext(device);
return;
}
StartDetection();
});
OpenBrowserCommand = ReactiveCommand.CreateFromTask(async() =>
await IoHelpers.OpenBrowserAsync("https://docs.wasabiwallet.io/using-wasabi/ColdWasabi.html#using-hardware-wallet-step-by-step"));
NavigateToExistingWalletLoginCommand = ReactiveCommand.Create(() =>
{
var navBar = NavigationManager.Get <NavBarViewModel>();
if (ExistingWallet is { } && navBar is { })
public ConnectHardwareWalletViewModel(WalletManagerViewModel owner) : base("Hardware Wallet")
{
Global = Locator.Current.GetService <Global>();
WalletManager = Global.WalletManager;
Owner = owner;
Wallets = new ObservableCollection <HardwareWalletViewModel>();
IsHwWalletSearchTextVisible = false;
this.WhenAnyValue(x => x.SelectedWallet)
.Where(x => x is null)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ =>
{
SelectedWallet = Wallets.FirstOrDefault();
SetLoadButtonText();
});
Wallets
.ToObservableChangeSet()
.ToCollection()
.Where(items => items.Any() && SelectedWallet is null)
.Select(items => items.First())
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedWallet = x);
this.WhenAnyValue(x => x.IsBusy, x => x.IsHardwareBusy)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => SetLoadButtonText());
LoadCommand = ReactiveCommand.CreateFromTask(LoadWalletAsync, this.WhenAnyValue(x => x.SelectedWallet, x => x.IsBusy).Select(x => x.Item1 is { } && !x.Item2));
public RecoverWalletViewModel(WalletManagerViewModel owner) : base("Recover Wallet")
{
Global = Locator.Current.GetService <Global>();
WalletManager = Global.WalletManager;
this.ValidateProperty(x => x.Password, ValidatePassword);
this.ValidateProperty(x => x.MinGapLimit, ValidateMinGapLimit);
this.ValidateProperty(x => x.AccountKeyPath, ValidateAccountKeyPath);
MnemonicWords = "";
var canExecute = Observable
.Merge(Observable.FromEventPattern(this, nameof(ErrorsChanged)).Select(_ => Unit.Default))
.Merge(this.WhenAnyValue(x => x.MnemonicWords).Select(_ => Unit.Default))
.ObserveOn(RxApp.MainThreadScheduler)
.Select(_ => !Validations.AnyErrors && MnemonicWords.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length == 12);
RecoverCommand = ReactiveCommand.Create(() => RecoverWallet(owner), canExecute);
this.WhenAnyValue(x => x.MnemonicWords).Subscribe(UpdateSuggestions);
_suggestions = new ObservableCollection <SuggestionViewModel>();
RecoverCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
protected ClosedWalletViewModel(WalletManagerViewModel walletManagerViewModel, Wallet wallet)
: base(wallet)
{
_smartHeaderChain = Services.BitcoinStore.SmartHeaderChain;
OpenCommand = ReactiveCommand.Create(() => OnOpen(walletManagerViewModel));
}
public RecoverWalletViewModel(WalletManagerViewModel owner) : base("Recover Wallet")
{
Global = Locator.Current.GetService <Global>();
WalletManager = Global.WalletManager;
this.ValidateProperty(x => x.Password, ValidatePassword);
this.ValidateProperty(x => x.MinGapLimit, ValidateMinGapLimit);
this.ValidateProperty(x => x.AccountKeyPath, ValidateAccountKeyPath);
MnemonicWords = "";
RecoverCommand = ReactiveCommand.Create(() =>
{
RecoverWallet(owner);
},
Observable.FromEventPattern(this, nameof(ErrorsChanged))
.ObserveOn(RxApp.MainThreadScheduler)
.Select(_ => !Validations.AnyErrors)
);
this.WhenAnyValue(x => x.MnemonicWords).Subscribe(UpdateSuggestions);
_suggestions = new ObservableCollection <SuggestionViewModel>();
RecoverCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
public static WalletViewModelBase Create(WalletManagerViewModel walletManager, Wallet wallet)
{
return(wallet.KeyManager.IsHardwareWallet
? new ClosedHardwareWalletViewModel(walletManager, wallet)
: wallet.KeyManager.IsWatchOnly
? new ClosedWatchOnlyWalletViewModel(walletManager, wallet)
: new ClosedWalletViewModel(walletManager, wallet));
}
public NavBarViewModel(NavigationStateViewModel navigationState, RoutingState router, WalletManagerViewModel walletManager, AddWalletPageViewModel addWalletPage)
{
Router = router;
_walletManager = walletManager;
_topItems = new ObservableCollection <NavBarItemViewModel>();
_bottomItems = new ObservableCollection <NavBarItemViewModel>();
var homePage = new HomePageViewModel(navigationState, walletManager, addWalletPage);
var settingsPage = new SettingsPageViewModel(navigationState);
var searchPage = new SearchPageViewModel(navigationState, walletManager, addWalletPage, settingsPage, homePage);
_selectedItem = homePage;
_topItems.Add(SelectedItem);
_bottomItems.Add(searchPage);
_bottomItems.Add(settingsPage);
_bottomItems.Add(addWalletPage);
Router.CurrentViewModel
.OfType <NavBarItemViewModel>()
.Subscribe(
x =>
{
if (walletManager.Items.Contains(x) || _topItems.Contains(x) || _bottomItems.Contains(x))
{
if (!_isNavigating)
{
_isNavigating = true;
SelectedItem = x;
_isNavigating = false;
}
}
});
this.WhenAnyValue(x => x.SelectedItem)
.OfType <NavBarItemViewModel>()
.Subscribe(
x =>
{
if (!_isNavigating)
{
_isNavigating = true;
x.NavigateToSelfAndReset(x.CurrentTarget);
CollapseOnClickAction?.Invoke();
_isNavigating = false;
}
});
Observable.FromEventPattern(Router.NavigationStack, nameof(Router.NavigationStack.CollectionChanged))
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => IsBackButtonVisible = Router.NavigationStack.Count > 1);
this.WhenAnyValue(x => x.IsOpen)
.Subscribe(x => SelectedItem.IsExpanded = x);
}
public RecoverWalletViewModel(
string walletName,
WalletManagerViewModel walletManagerViewModel)
{
Suggestions = new Mnemonic(Wordlist.English, WordCount.Twelve).WordList.GetWords();
var walletManager = walletManagerViewModel.WalletManager;
var network = walletManager.Network;
Mnemonics.ToObservableChangeSet().ToCollection()
.Select(x => x.Count == 12 ? new Mnemonic(GetTagsAsConcatString().ToLowerInvariant()) : default)
public GenerateWalletViewModel(WalletManagerViewModel owner) : base("Generate Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
this.ValidateProperty(x => x.Password, ValidatePassword);
NextCommand = ReactiveCommand.Create(DoNextCommand, this.WhenAnyValue(x => x.Validations.Any).Select(x => !x));
NextCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
public GenerateWalletViewModel(WalletManagerViewModel owner) : base("Generate Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
IObservable <bool> canGenerate = this.WhenAnyValue(x => x.Password).Select(pw => !ValidatePassword().HasErrors);
NextCommand = ReactiveCommand.Create(DoNextCommand, canGenerate);
NextCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
private async Task OnNext(WalletManagerViewModel walletManagerViewModel, ClosedWalletViewModel closedWalletViewModel, Wallet wallet)
{
string?compatibilityPasswordUsed = null;
var isPasswordCorrect = await Task.Run(() => wallet.TryLogin(Password, out compatibilityPasswordUsed));
if (!isPasswordCorrect)
{
ErrorMessage = "The password is incorrect! Try Again.";
return;
}
if (compatibilityPasswordUsed is { })
public SearchPageViewModel(NavigationStateViewModel navigationState, WalletManagerViewModel walletManager, AddWalletPageViewModel addWalletPage, SettingsPageViewModel settingsPage, HomePageViewModel homePage) : base(navigationState)
{
Title = "Search";
_showSettings = true;
_showWallets = false;
var generalCategory = new SearchCategory("General", 0);
var generalCategorySource = new SourceList <SearchItemViewModel>();
generalCategorySource.Add(CreateHomeSearchItem(generalCategory, 0, homePage));
generalCategorySource.Add(CreateSettingsSearchItem(generalCategory, 1, settingsPage));
generalCategorySource.Add(CreateAddWalletSearchItem(generalCategory, 2, addWalletPage));
var settingsCategory = new SearchCategory("Settings", 1);
var settingsCategorySource = new SourceList <SearchItemViewModel>();
settingsCategorySource.AddRange(CreateSettingsSearchItems(settingsCategory, settingsPage));
var walletCategory = new SearchCategory("Wallets", 2);
var wallets = walletManager.Items
.ToObservableChangeSet()
.Transform(x => CreateWalletSearchItem(walletCategory, 0, x))
.Sort(SortExpressionComparer <SearchItemViewModel> .Ascending(i => i.Title));
var searchItems = generalCategorySource.Connect();
if (_showSettings)
{
searchItems = searchItems.Merge(settingsCategorySource.Connect());
}
if (_showWallets)
{
searchItems = searchItems.Merge(wallets);
}
var queryFilter = this.WhenValueChanged(t => t.SearchQuery)
.Throttle(TimeSpan.FromMilliseconds(100))
.Select(SearchQueryFilter)
.DistinctUntilChanged();
searchItems
.Filter(queryFilter)
.GroupWithImmutableState(x => x.Category)
.Transform(grouping => new SearchResult(grouping.Key, grouping.Items.OrderBy(x => x.Order).ThenBy(x => x.Title)))
.Sort(SortExpressionComparer <SearchResult> .Ascending(i => i.Category.Order).ThenByAscending(i => i.Category.Title))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _searchResults)
.AsObservableList();
}
private bool _disposedValue = false; // To detect redundant calls
public LoadWalletViewModel(WalletManagerViewModel owner, LoadWalletType loadWalletType)
: base(loadWalletType == LoadWalletType.Password ? "Test Password" : "Load Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
Password = "";
LoadWalletType = loadWalletType;
this.ValidateProperty(x => x.Password, ValidatePassword);
RootList = new SourceList <WalletViewModelBase>();
RootList.Connect()
.AutoRefresh(model => model.WalletState)
.Filter(x => (!IsPasswordRequired || !x.Wallet.KeyManager.IsWatchOnly))
.Sort(SortExpressionComparer <WalletViewModelBase>
.Descending(p => p.Wallet.KeyManager.GetLastAccessTime()),
resort: ResortTrigger.AsObservable())
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _wallets)
.DisposeMany()
.Subscribe()
.DisposeWith(Disposables);
Observable.FromEventPattern <Wallet>(Global.WalletManager, nameof(Global.WalletManager.WalletAdded))
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => x.EventArgs)
.Subscribe(wallet => RootList.Add(new WalletViewModelBase(wallet)))
.DisposeWith(Disposables);
this.WhenAnyValue(x => x.SelectedWallet)
.Where(x => x is null)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => SelectedWallet = Wallets.FirstOrDefault());
Wallets
.ToObservableChangeSet()
.ToCollection()
.Where(items => items.Any() && SelectedWallet is null)
.Select(items => items.First())
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedWallet = x);
LoadCommand = ReactiveCommand.Create(() =>
RxApp.MainThreadScheduler
.Schedule(async() => await LoadWalletAsync())
.DisposeWith(Disposables),
this.WhenAnyValue(x => x.SelectedWallet, x => x?.WalletState)
.Select(x => x == WalletState.Uninitialized));
TestPasswordCommand = ReactiveCommand.Create(LoadKeyManager, this.WhenAnyValue(x => x.SelectedWallet).Select(x => x is { }));
public GenerateWalletSuccessViewModel(WalletManagerViewModel owner, KeyManager keyManager, Mnemonic mnemonic) : base("Wallet Generated Successfully!")
{
_mnemonicWords = mnemonic.ToString();
ConfirmCommand = ReactiveCommand.Create(() =>
{
keyManager.ToFile();
NotificationHelpers.Success("Wallet was generated.");
owner.SelectTestPassword();
});
ConfirmCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
public GenerateWalletSuccessViewModel(WalletManagerViewModel owner, KeyManager keyManager, Mnemonic mnemonic) : base("Wallet Generated Successfully!")
{
_mnemonicWords = mnemonic.ToString();
var global = Locator.Current.GetService <Global>();
ConfirmCommand = ReactiveCommand.Create(() =>
{
var wallet = global.WalletManager.AddWallet(keyManager);
NotificationHelpers.Success("Wallet was generated.");
owner.SelectTestPassword(wallet.WalletName);
});
ConfirmCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
protected ClosedWalletViewModel(WalletManagerViewModel walletManagerViewModel, Wallet wallet)
: base(wallet)
{
_items = new ObservableCollection <NavBarItemViewModel>();
OpenCommand = ReactiveCommand.Create(() =>
{
if (!Wallet.IsLoggedIn)
{
Navigate().To(new LoginViewModel(walletManagerViewModel, this), NavigationMode.Clear);
}
else
{
Navigate().To(this, NavigationMode.Clear);
}
});
}
private void DisplayWalletManager()
{
var walletManagerViewModel = new WalletManagerViewModel();
IoC.Get <IShell>().AddDocument(walletManagerViewModel);
var isAnyDesktopWalletAvailable = Directory.Exists(Global.WalletsDir) && Directory.EnumerateFiles(Global.WalletsDir).Any();
if (isAnyDesktopWalletAvailable)
{
walletManagerViewModel.SelectLoadWallet();
}
else
{
walletManagerViewModel.SelectGenerateWallet();
}
}
public LoginViewModel(WalletManagerViewModel walletManagerViewModel, ClosedWalletViewModel closedWalletViewModel)
{
var wallet = closedWalletViewModel.Wallet;
IsPasswordNeeded = !wallet.KeyManager.IsWatchOnly;
WalletName = wallet.WalletName;
_password = "";
_errorMessage = "";
WalletType = WalletHelpers.GetType(closedWalletViewModel.Wallet.KeyManager);
NextCommand = ReactiveCommand.CreateFromTask(async() => await OnNextAsync(walletManagerViewModel, closedWalletViewModel, wallet));
OkCommand = ReactiveCommand.Create(OnOk);
ForgotPasswordCommand = ReactiveCommand.Create(() => OnForgotPassword(wallet));
EnableAutoBusyOn(NextCommand);
}
private void RecoverWallet(WalletManagerViewModel owner)
{
WalletName = Guard.Correct(WalletName);
MnemonicWords = Guard.Correct(MnemonicWords);
Password = Guard.Correct(Password); // Do not let whitespaces to the beginning and to the end.
string walletFilePath = WalletManager.WalletDirectories.GetWalletFilePaths(WalletName).walletFilePath;
if (string.IsNullOrWhiteSpace(WalletName))
{
NotificationHelpers.Error("Invalid wallet name.");
}
else if (File.Exists(walletFilePath))
{
NotificationHelpers.Error("Wallet name is already taken.");
}
else if (string.IsNullOrWhiteSpace(MnemonicWords))
{
NotificationHelpers.Error("Recovery Words were not supplied.");
}
else
{
var minGapLimit = int.Parse(MinGapLimit);
var keyPath = KeyPath.Parse(AccountKeyPath);
try
{
var mnemonic = new Mnemonic(MnemonicWords);
var km = KeyManager.Recover(mnemonic, Password, filePath: null, keyPath, minGapLimit);
km.SetNetwork(Global.Network);
km.SetFilePath(walletFilePath);
WalletManager.AddWallet(km);
NotificationHelpers.Success("Wallet was recovered.");
owner.SelectLoadWallet(km);
}
catch (Exception ex)
{
Logger.LogError(ex);
NotificationHelpers.Error(ex.ToUserFriendlyString());
}
}
}
public LoginViewModel(WalletManagerViewModel walletManagerViewModel, ClosedWalletViewModel closedWalletViewModel)
{
var wallet = closedWalletViewModel.Wallet;
IsPasswordNeeded = !wallet.KeyManager.IsWatchOnly;
WalletName = wallet.WalletName;
_password = "";
_errorMessage = "";
WalletIcon = wallet.KeyManager.Icon;
IsHardwareWallet = wallet.KeyManager.IsHardwareWallet;
NextCommand = ReactiveCommand.CreateFromTask(async() =>
{
string?compatibilityPasswordUsed = null;
var isPasswordCorrect = await Task.Run(() => wallet.TryLogin(Password, out compatibilityPasswordUsed));
if (!isPasswordCorrect)
{
ErrorMessage = "The password is incorrect! Try Again.";
return;
}
if (compatibilityPasswordUsed is { })
{
await ShowErrorAsync(Title, PasswordHelper.CompatibilityPasswordWarnMessage, "Compatibility password was used");
}
var legalResult = await ShowLegalAsync(walletManagerViewModel.LegalChecker);
if (legalResult)
{
await LoginWalletAsync(walletManagerViewModel, closedWalletViewModel);
}
else
{
wallet.Logout();
ErrorMessage = "You must accept the Terms and Conditions!";
}
});
public GenerateWalletSuccessViewModel(WalletManagerViewModel owner, KeyManager keyManager, Mnemonic mnemonic) : base("Wallet Generated Successfully!")
{
_mnemonicWords = new List <string>(mnemonic.Words.Length);
for (int i = 0; i < mnemonic.Words.Length; i++)
{
_mnemonicWords.Add($"{i + 1}. {mnemonic.Words[i]}");
}
var global = Locator.Current.GetService <Global>();
ConfirmCommand = ReactiveCommand.Create(() =>
{
var wallet = global.WalletManager.AddWallet(keyManager);
NotificationHelpers.Success("Wallet was generated.");
owner.SelectTestPassword(wallet.WalletName);
}, this.WhenAnyValue(x => x.IsConfirmed));
ConfirmCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
public LoadWalletViewModel(WalletManagerViewModel owner, LoadWalletType loadWalletType)
: base(loadWalletType == LoadWalletType.Password ? "Test Password" : loadWalletType == LoadWalletType.Desktop ? "Load Wallet" : "Hardware Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
Password = "";
LoadWalletType = loadWalletType;
Wallets = new ObservableCollection <LoadWalletEntry>();
IsHwWalletSearchTextVisible = false;
this.WhenAnyValue(x => x.SelectedWallet)
.Subscribe(_ => TrySetWalletStates());
this.WhenAnyValue(x => x.IsWalletOpened)
.Subscribe(_ => TrySetWalletStates());
this.WhenAnyValue(x => x.IsBusy)
.Subscribe(_ => TrySetWalletStates());
LoadCommand = ReactiveCommand.CreateFromTask(LoadWalletAsync, this.WhenAnyValue(x => x.CanLoadWallet));
TestPasswordCommand = ReactiveCommand.CreateFromTask(LoadKeyManagerAsync, this.WhenAnyValue(x => x.CanTestPassword));
OpenFolderCommand = ReactiveCommand.Create(OpenWalletsFolder);
OpenBrowserCommand = ReactiveCommand.CreateFromTask <string>(IoHelpers.OpenBrowserAsync);
Observable
.Merge(OpenBrowserCommand.ThrownExceptions)
.Merge(LoadCommand.ThrownExceptions)
.Merge(TestPasswordCommand.ThrownExceptions)
.Merge(OpenFolderCommand.ThrownExceptions)
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex =>
{
Logger.LogError(ex);
NotificationHelpers.Error(ex.ToUserFriendlyString());
});
SetLoadButtonText();
}
public AddWalletPageViewModel(
WalletManagerViewModel walletManagerViewModel,
BitcoinStore store)
{
Title = "Add Wallet";
SelectionMode = NavBarItemSelectionMode.Button;
var walletManager = walletManagerViewModel.WalletManager;
var network = walletManager.Network;
var enableBack = default(IDisposable);
this.WhenAnyValue(x => x.CurrentTarget)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x =>
{
enableBack?.Dispose();
enableBack = Navigate()
.WhenAnyValue(y => y.CanNavigateBack)
.Subscribe(y => EnableBack = y);
});
this.WhenAnyValue(x => x.WalletName)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => !string.IsNullOrWhiteSpace(x))
.Subscribe(x => OptionsEnabled = x && !Validations.Any);
RecoverWalletCommand = ReactiveCommand.Create(() => OnRecoverWallet(walletManagerViewModel));
ImportWalletCommand = ReactiveCommand.CreateFromTask(async() => await OnImportWallet(walletManager));
ConnectHardwareWalletCommand = ReactiveCommand.Create(() => OnConnectHardwareWallet(walletManagerViewModel));
CreateWalletCommand = ReactiveCommand.CreateFromTask(async() => await OnCreateWallet(walletManager, store, network));
this.ValidateProperty(x => x.WalletName, errors => ValidateWalletName(errors, walletManager, WalletName));
EnableAutoBusyOn(CreateWalletCommand);
}
public ConnectHardwareWalletViewModel(string walletName, WalletManagerViewModel walletManagerViewModel)
{
_message = "";
WalletName = walletName;
WalletManager = walletManagerViewModel.WalletManager;
Wallets = walletManagerViewModel.Wallets;
AbandonedTasks = new AbandonedTasks();
CancelCts = new CancellationTokenSource();
EnableCancel = true;
EnableBack = true;
NextCommand = ReactiveCommand.Create(OnNext);
OpenBrowserCommand = ReactiveCommand.CreateFromTask(async() =>
await IoHelpers.OpenBrowserAsync("https://docs.wasabiwallet.io/using-wasabi/ColdWasabi.html#using-hardware-wallet-step-by-step"));
NavigateToExistingWalletLoginCommand = ReactiveCommand.Create(execute: OnNavigateToExistingWalletLogin);
this.WhenAnyValue(x => x.Message)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(message => ConfirmationRequired = !string.IsNullOrEmpty(message));
}
internal ClosedHardwareWalletViewModel(WalletManagerViewModel walletManager, Wallet wallet) : base(walletManager, wallet)
{
}
public RecoverWalletViewModel(WalletManagerViewModel owner) : base("Recover Wallet")
{
Global = Locator.Current.GetService <Global>();
MnemonicWords = "";
RecoverCommand = ReactiveCommand.Create(() =>
{
WalletName = Guard.Correct(WalletName);
MnemonicWords = Guard.Correct(MnemonicWords);
Password = Guard.Correct(Password); // Do not let whitespaces to the beginning and to the end.
string walletFilePath = Global.WalletManager.WalletDirectories.GetWalletFilePaths(WalletName).walletFilePath;
if (string.IsNullOrWhiteSpace(WalletName))
{
NotificationHelpers.Error("Invalid wallet name.");
}
else if (File.Exists(walletFilePath))
{
NotificationHelpers.Error("Wallet name is already taken.");
}
else if (string.IsNullOrWhiteSpace(MnemonicWords))
{
NotificationHelpers.Error("Recovery Words were not supplied.");
}
else if (string.IsNullOrWhiteSpace(AccountKeyPath))
{
NotificationHelpers.Error("The account key path is not valid.");
}
else if (MinGapLimit < KeyManager.AbsoluteMinGapLimit)
{
NotificationHelpers.Error($"Min Gap Limit cannot be smaller than {KeyManager.AbsoluteMinGapLimit}.");
}
else if (MinGapLimit > 1_000_000)
{
NotificationHelpers.Error($"Min Gap Limit cannot be larger than {1_000_000}.");
}
else if (!KeyPath.TryParse(AccountKeyPath, out KeyPath keyPath))
{
NotificationHelpers.Error("The account key path is not a valid derivation path.");
}
else
{
try
{
var mnemonic = new Mnemonic(MnemonicWords);
var km = KeyManager.Recover(mnemonic, Password, filePath: null, keyPath, MinGapLimit);
km.SetNetwork(Global.Network);
km.SetFilePath(walletFilePath);
km.ToFile();
NotificationHelpers.Success("Wallet was recovered.");
owner.SelectLoadWallet();
}
catch (Exception ex)
{
Logger.LogError(ex);
NotificationHelpers.Error(ex.ToUserFriendlyString());
}
}
});
this.WhenAnyValue(x => x.MnemonicWords).Subscribe(UpdateSuggestions);
_suggestions = new ObservableCollection <SuggestionViewModel>();
RecoverCommand.ThrownExceptions
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex => Logger.LogError(ex));
}
private void OnRecoverWallet(WalletManagerViewModel walletManagerViewModel)
{
Navigate().To(new RecoverWalletViewModel(WalletName, walletManagerViewModel));
}
private void OnConnectHardwareWallet(WalletManagerViewModel walletManagerViewModel)
{
Navigate().To(new ConnectHardwareWalletViewModel(WalletName, walletManagerViewModel));
}
public AddWalletPageViewModel(
WalletManagerViewModel walletManagerViewModel,
BitcoinStore store)
{
Title = "Add Wallet";
SelectionMode = NavBarItemSelectionMode.Button;
var walletManager = walletManagerViewModel.Model;
var network = walletManager.Network;
var enableBack = default(IDisposable);
this.WhenAnyValue(x => x.CurrentTarget)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x =>
{
enableBack?.Dispose();
enableBack = Navigate()
.WhenAnyValue(y => y.CanNavigateBack)
.Subscribe(y => EnableBack = y);
});
this.WhenAnyValue(x => x.WalletName)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => !string.IsNullOrWhiteSpace(x))
.Subscribe(x => OptionsEnabled = x && !Validations.Any);
RecoverWalletCommand = ReactiveCommand.Create(
() => Navigate().To(new RecoverWalletViewModel(WalletName, walletManagerViewModel)));
ImportWalletCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
var filePath = await FileDialogHelper.ShowOpenFileDialogAsync("Import wallet file", new[] { "json" });
if (filePath is null)
{
return;
}
var keyManager = await ImportWalletHelper.ImportWalletAsync(walletManager, WalletName, filePath);
// TODO: get the type from the wallet file
Navigate().To(new AddedWalletPageViewModel(walletManager, keyManager));
}
catch (Exception ex)
{
Logger.LogError(ex);
await ShowErrorAsync(ex.ToUserFriendlyString(), "The wallet file was not valid or compatible with Wasabi.");
}
});
ConnectHardwareWalletCommand = ReactiveCommand.Create(() => Navigate().To(new ConnectHardwareWalletViewModel(WalletName, walletManagerViewModel)));
CreateWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var dialogResult = await NavigateDialog(
new EnterPasswordViewModel("Type the password of the wallet and click Continue."));
if (dialogResult.Result is { } password)
{
var(km, mnemonic) = await Task.Run(
() =>
{
var walletGenerator = new WalletGenerator(
walletManager.WalletDirectories.WalletsDir,
network)
{
TipHeight = store.SmartHeaderChain.TipHeight
};
return(walletGenerator.GenerateWallet(WalletName, password));
});
Navigate().To(new RecoveryWordsViewModel(km, mnemonic, walletManager));
}
});
this.ValidateProperty(x => x.WalletName, errors => ValidateWalletName(errors, walletManager, WalletName));
EnableAutoBusyOn(CreateWalletCommand);
}
