public LegalDocumentsViewModel(NavigationStateViewModel navigationState, string content) :
base(navigationState)
{
Content = content;
NextCommand = BackCommand;
}
public WalletManagerViewModel(NavigationStateViewModel navigationState, string title) : base(navigationState, "WalletManager", title)
{
#if !USE_DIALOG
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
#else
ShowCommand = ReactiveCommand.Create(() => navigationState.Dialog().Router.Navigate.Execute(this));
#endif
var navigationStateWalletManager = new NavigationStateViewModel()
{
Screen = () => navigationState.Screen(),
Dialog = () => navigationState.Dialog(),
NextView = () => _home,
CancelView = () => _home,
};
_items = new ObservableCollection <RoutableViewModel>
{
new GenerateWalletViewModel(navigationStateWalletManager, "Create new Wallet", this),
new RecoverWalletViewModel(navigationStateWalletManager, "Recover Wallet"),
new LoadWalletViewModel(navigationStateWalletManager, "Import Wallet"),
new TestPasswordViewModel(navigationStateWalletManager, "Test Password"),
new HardwareWalletViewModel(navigationStateWalletManager, "Connect HW Wallet")
};
_wallets = new ObservableCollection <RoutableViewModel>
{
new WalletViewModel(navigationStateWalletManager, "Random Wallet (0 BTC)"),
new WalletViewModel(navigationStateWalletManager, "Random Wallet 2 (0 BTC)"),
new WalletViewModel(navigationStateWalletManager, "Random Wallet 3 (0 BTC)"),
new WalletViewModel(navigationStateWalletManager, "Random Wallet 4 (0 BTC)")
};
}
public GenerateWalletPasswordViewModel(NavigationStateViewModel navigationState, IScreen wizardScreen, string title, WalletViewModel wallet, WalletManagerViewModel walletManager)
: base(new NavigationStateViewModel()
{
Screen = () => wizardScreen,
Dialog = () => navigationState.Dialog(),
NextView = () => navigationState.NextView(),
CancelView = () => navigationState.CancelView(),
}, "GenerateWalletPassword", title)
{
ShowCommand = ReactiveCommand.Create(() => wizardScreen.Router.Navigate.Execute(this));
#if !USE_DIALOG
CancelCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(navigationState.CancelView()));
#else
CancelCommand = ReactiveCommand.Create(() =>
{
navigationState.Dialog().Router.NavigationStack.Clear();
navigationState.Screen().Router.Navigate.Execute(navigationState.CancelView());
});
#endif
NextCommand = ReactiveCommand.Create(() =>
{
wallet.Password = _password;
wizardScreen.Router.Navigate.Execute(
new GenerateWalletRecoveryViewModel(navigationState, wizardScreen, "Create Wallet", wallet, walletManager));
});
}
public ConfirmRecoveryWordsViewModel(NavigationStateViewModel navigationState, List <RecoveryWordViewModel> mnemonicWords, KeyManager keyManager, WalletManager walletManager)
: base(navigationState, NavigationTarget.DialogScreen)
{
_confirmationWordsSourceList = new SourceList <RecoveryWordViewModel>();
var finishCommandCanExecute =
_confirmationWordsSourceList
.Connect()
.ObserveOn(RxApp.MainThreadScheduler)
.WhenValueChanged(x => x.IsConfirmed)
.Select(x => !_confirmationWordsSourceList.Items.Any(x => !x.IsConfirmed));
NextCommand = ReactiveCommand.Create(
() =>
{
walletManager.AddWallet(keyManager);
ClearNavigation(NavigationTarget.DialogScreen);
},
finishCommandCanExecute);
CancelCommand = ReactiveCommand.Create(() => ClearNavigation(NavigationTarget.DialogScreen));
_confirmationWordsSourceList
.Connect()
.ObserveOn(RxApp.MainThreadScheduler)
.OnItemAdded(x => x.Reset())
.Sort(SortExpressionComparer <RecoveryWordViewModel> .Ascending(x => x.Index))
.Bind(out _confirmationWords)
.Subscribe();
// Select 4 random words to confirm.
_confirmationWordsSourceList.AddRange(mnemonicWords.OrderBy(x => new Random().NextDouble()).Take(4));
}
protected ClosedWalletViewModel(NavigationStateViewModel navigationState, WalletManager walletManager, Wallet wallet) : base(navigationState, wallet)
{
_items = new ObservableCollection <NavBarItemViewModel>
{
new SettingsPageViewModel(navigationState)
{
Parent = this
}
};
OpenWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
try
{
if (wallet.KeyManager.PasswordVerified is true)
{
// TODO ... new UX will test password earlier...
}
await Task.Run(async() => await walletManager.StartWalletAsync(Wallet));
}
catch (OperationCanceledException ex)
{
Logger.LogTrace(ex);
}
catch (Exception ex)
{
NotificationHelpers.Error($"Couldn't load wallet. Reason: {ex.ToUserFriendlyString()}", sender: wallet);
Logger.LogError(ex);
}
},
this.WhenAnyValue(x => x.WalletState).Select(x => x == WalletState.Uninitialized));
}
public ImportWalletViewModel(NavigationStateViewModel navigationState, string walletName, WalletManager walletManager) : base(navigationState)
{
WalletName = walletName;
WalletManager = walletManager;
ImportWallet();
}
static public void NavigateToNextPage(NavigationStateViewModel navigationState, bool isReturningStudent = false)
{
var primaryPage = App.Current.MainPage;
if (primaryPage.Navigation == null)
{
return;
}
MasterPage Instance = (MasterPage)primaryPage.Navigation.NavigationStack.First();
Type type = Type.GetType("MobileApps.Views.Navigation.SubViews." + GetNextView(navigationState.CurrentStep));
if (type == null)
{
return;
}
View newContent = (View)Activator.CreateInstance(type);
if (isReturningStudent)
{
Instance.WelcomeBackExistingStudent(newContent);
}
else
{
Instance.UpdateView(newContent);
}
}
public EnterPasswordViewModel(NavigationStateViewModel navigationState, NavigationTarget navigationTarget, string subtitle) : base(navigationState, navigationTarget)
{
Subtitle = subtitle;
// This means pressing continue will make the password empty string.
// pressing cancel will return null.
_password = "";
this.ValidateProperty(x => x.Password, ValidatePassword);
this.ValidateProperty(x => x.ConfirmPassword, ValidateConfirmPassword);
var backCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler);
var nextCommandCanExecute = this.WhenAnyValue(
x => x.IsDialogOpen,
x => x.Password,
x => x.ConfirmPassword,
(isDialogOpen, password, confirmPassword) =>
{
// This will fire validations before return canExecute value.
this.RaisePropertyChanged(nameof(Password));
this.RaisePropertyChanged(nameof(ConfirmPassword));
return(isDialogOpen && ((string.IsNullOrEmpty(password) && string.IsNullOrEmpty(confirmPassword)) || (!string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(confirmPassword) && !Validations.Any)));
})
.ObserveOn(RxApp.MainThreadScheduler);
var cancelCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler);
BackCommand = ReactiveCommand.Create(() => Close(), backCommandCanExecute);
NextCommand = ReactiveCommand.Create(() => Close(Password), nextCommandCanExecute);
CancelCommand = ReactiveCommand.Create(() => Close(), cancelCommandCanExecute);
}
public LegalDocumentHelpViewModel(NavigationStateViewModel navigationState, string title) : base(navigationState, "LegalDocumentHelp", title)
{
#if !USE_DIALOG
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
#else
ShowCommand = ReactiveCommand.Create(() => navigationState.Dialog().Router.Navigate.Execute(this));
#endif
}
public AnonymityLevelsSettingsViewModel(NavigationStateViewModel navigationState, string title) : base(navigationState, "AnonymityLevelsSettings", title)
{
#if !USE_DIALOG
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
#else
ShowCommand = ReactiveCommand.Create(() => navigationState.Dialog().Router.Navigate.Execute(this));
#endif
}
public RecoverWalletViewModel(NavigationStateViewModel navigationState, string title) : base(navigationState, "RecoverWallet", title)
{
#if !USE_DIALOG
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
#else
ShowCommand = ReactiveCommand.Create(() => navigationState.Dialog().Router.Navigate.Execute(this));
#endif
}
public AddWalletViewModel(NavigationStateViewModel navigationState, string title, WalletManagerViewModel walletManager) : base(navigationState, "AddWallet", title)
{
#if !USE_DIALOG
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(walletManager));
#else
ShowCommand = ReactiveCommand.Create(() => navigationState.Dialog().Router.Navigate.Execute(walletManager));
#endif
}
protected DialogViewModelBase(NavigationStateViewModel navigationState, NavigationTarget navigationTarget) : base(navigationState, navigationTarget)
{
_currentTaskCompletionSource = new TaskCompletionSource <TResult>();
_disposable = this.WhenAnyValue(x => x.IsDialogOpen)
.Skip(1) // Skip the initial value change (which is false).
.DistinctUntilChanged()
.Subscribe(OnIsDialogOpenChanged);
}
protected NavBarItemViewModel(NavigationStateViewModel navigationState) : base(navigationState)
{
_title = "";
OpenCommand = ReactiveCommand.Create(
() =>
{
NavigateToSelf();
});
}
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(
NavigationStateViewModel navigationState,
string walletName,
Network network,
WalletManager walletManager) : base(navigationState)
{
Suggestions = new Mnemonic(Wordlist.English, WordCount.Twelve).WordList.GetWords();
Mnemonics.ToObservableChangeSet().ToCollection()
.Select(x => x.Count == 12 ? new Mnemonic(GetTagsAsConcatString()) : default)
protected DialogViewModelBase(NavigationStateViewModel navigationState) : base(navigationState)
{
_currentTaskCompletionSource = new TaskCompletionSource <TResult>();
_disposable = this.WhenAnyValue(x => x.IsDialogOpen)
.Skip(1) // Skip the initial value change (which is false).
.DistinctUntilChanged()
.Subscribe(OnIsDialogOpenChanged);
CancelCommand = ReactiveCommand.Create(() => Close());
}
public HelpViewModel(NavigationStateViewModel navigationState) : base(navigationState, "Help", "Help")
{
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
_items = new ObservableCollection <RoutableViewModel>
{
new AboutHelpViewModel(navigationState, "About"),
new UserSupportHelpViewModel(navigationState, "User Support"),
new ReportBugHelpViewModel(navigationState, "Report Bug"),
new DocumentationHelpViewModel(navigationState, "Documentation"),
new LegalDocumentHelpViewModel(navigationState, "Legal Document")
};
}
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();
}
public TestDialogViewModel(NavigationStateViewModel navigationState, NavigationTarget navigationTarget, string message) : base(navigationState, navigationTarget)
{
_message = message;
var backCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler);
var cancelCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler);
var nextCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler);
BackCommand = ReactiveCommand.Create(() => GoBack(), backCommandCanExecute);
CancelCommand = ReactiveCommand.Create(() => Close(false), cancelCommandCanExecute);
NextCommand = ReactiveCommand.Create(() => Close(true), nextCommandCanExecute);
}
public SettingsViewModel(NavigationStateViewModel navigationState) : base(navigationState, "Settings", "Settings")
{
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
_items = new ObservableCollection <RoutableViewModel>
{
new BitcoinSettingsViewModel(navigationState, "Bitcoin"),
new TorSettingsViewModel(navigationState, "Tor"),
new UISettingsViewModel(navigationState, "UI"),
new LockScreenSettingsViewModel(navigationState, "Lock Screen"),
new AnonymityLevelsSettingsViewModel(navigationState, "Anonymity Levels"),
new OtherSettingsSettingsViewModel(navigationState, "Other Settings")
};
}
public AddWalletPageViewModel(NavigationStateViewModel navigationState, LegalDocuments legalDocuments, WalletManager walletManager,
BitcoinStore store, Network network) : base(navigationState)
{
Title = "Add Wallet";
_legalDocuments = legalDocuments;
this.WhenAnyValue(x => x.WalletName)
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => !string.IsNullOrWhiteSpace(x))
.Subscribe(x => OptionsEnabled = x && !Validations.Any);
RecoverWalletCommand = ReactiveCommand.Create(() =>
{
NavigateTo(new RecoverWalletViewModel(navigationState, WalletName, network, walletManager));
});
ImportWalletCommand = ReactiveCommand.Create(() => new ImportWalletViewModel(navigationState, WalletName, walletManager));
CreateWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var result = await NavigateDialog(new EnterPasswordViewModel(
navigationState,
"Type the password of the wallet and click Continue."));
if (result is { } password)
{
IsBusy = true;
var(km, mnemonic) = await Task.Run(
() =>
{
var walletGenerator = new WalletGenerator(
walletManager.WalletDirectories.WalletsDir,
network)
{
TipHeight = store.SmartHeaderChain.TipHeight
};
return(walletGenerator.GenerateWallet(WalletName, password));
});
NavigateTo(new RecoveryWordsViewModel(navigationState, km, mnemonic, walletManager), true);
IsBusy = false;
}
});
this.ValidateProperty(x => x.WalletName, errors => ValidateWalletName(errors, walletManager, WalletName));
}
public SearchItemViewModel(
string title,
string caption,
int order,
SearchCategory category,
string keywords,
string iconName,
NavigationStateViewModel navigationState,
Func <RoutableViewModel> createTargetView) : base(navigationState)
{
Title = title;
Caption = caption;
Order = order;
Category = category;
Keywords = keywords;
IconName = iconName;
OpenCommand = ReactiveCommand.Create(() => NavigateTo(createTargetView(), CurrentTarget));
}
public RecoveryWordsViewModel(
NavigationStateViewModel navigationState,
KeyManager keyManager,
Mnemonic mnemonic,
WalletManager walletManager)
: base(navigationState, NavigationTarget.DialogScreen)
{
MnemonicWords = new List <RecoveryWordViewModel>();
for (int i = 0; i < mnemonic.Words.Length; i++)
{
MnemonicWords.Add(new RecoveryWordViewModel(i + 1, mnemonic.Words[i]));
}
NextCommand = ReactiveCommand.Create(
() => NavigateTo(new ConfirmRecoveryWordsViewModel(navigationState, MnemonicWords, keyManager, walletManager), NavigationTarget.DialogScreen));
CancelCommand = ReactiveCommand.Create(() => ClearNavigation(NavigationTarget.DialogScreen));
}
protected WalletViewModelBase(NavigationStateViewModel navigationState, Wallet wallet) : base(navigationState)
{
Wallet = Guard.NotNull(nameof(wallet), wallet);
_disposables = new CompositeDisposable();
Title = WalletName;
var isHardware = Wallet.KeyManager.IsHardwareWallet;
var isWatch = Wallet.KeyManager.IsWatchOnly;
_titleTip = isHardware ? "Hardware Wallet" : isWatch ? "Watch Only Wallet" : "Hot Wallet";
WalletState = wallet.State;
Observable.FromEventPattern <WalletState>(wallet, nameof(wallet.StateChanged))
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => WalletState = x.EventArgs)
.DisposeWith(_disposables);
}
public WalletExplorerViewModel(NavigationStateViewModel navigationState, WalletManagerViewModel walletManager) : base(navigationState, "WalletExplorer", "Wallet Explorer")
{
ShowCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.Navigate.Execute(this));
var navigationStateWalletExplorer = new NavigationStateViewModel()
{
Screen = () => navigationState.Screen(),
Dialog = () => navigationState.Dialog(),
NextView = () => this,
CancelView = () => this,
};
var list = new SourceList <RoutableViewModel>();
list.Add(new AddWalletViewModel(navigationStateWalletExplorer, "Add Wallet", walletManager));
walletManager.Wallets.ToObservableChangeSet()
.Merge(list.Connect())
.Bind(out _items)
.AsObservableList();
}
public GenerateWalletViewModel(NavigationStateViewModel navigationState, string title, WalletManagerViewModel walletManager) : base(navigationState, "GenerateWallet", title)
{
ShowCommand = ReactiveCommand.Create(() =>
{
#if !USE_DIALOG
navigationState.Screen().Router.Navigate.Execute(this);
#else
navigationState.Dialog().Router.Navigate.Execute(this);
#endif
Router.NavigateAndReset.Execute(
new GenerateWalletPasswordViewModel(
navigationState,
this,
"Create Wallet",
new WalletViewModel(navigationState, walletManager.Name)
{
Name = walletManager.Name
},
walletManager));
});
}
public TermsAndConditionsViewModel(NavigationStateViewModel navigationState, LegalDocuments legalDocuments, RoutableViewModel next) : base(navigationState)
{
ViewTermsCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var content = await File.ReadAllTextAsync(legalDocuments.FilePath);
var legalDocs = new LegalDocumentsViewModel(
navigationState,
content);
legalDocs.NavigateToSelf(CurrentTarget);
});
NextCommand = ReactiveCommand.Create(
() =>
{
NavigateTo(next);
},
this.WhenAnyValue(x => x.IsAgreed).ObserveOn(RxApp.MainThreadScheduler));
}
public GenerateWalletConfirmViewModel(NavigationStateViewModel navigationState, IScreen wizardScreen, string title, WalletViewModel wallet, WalletManagerViewModel walletManager)
: base(new NavigationStateViewModel()
{
Screen = () => wizardScreen,
Dialog = () => navigationState.Dialog(),
NextView = () => navigationState.NextView(),
CancelView = () => navigationState.CancelView(),
}, "GenerateWalletConfirm", title)
{
_recoveryWords = wallet.RecoveryWords;
ShowCommand = ReactiveCommand.Create(() => wizardScreen.Router.Navigate.Execute(this));
CancelCommand = ReactiveCommand.Create(() => navigationState.Screen().Router.NavigateAndReset.Execute(navigationState.CancelView()));
NextCommand = ReactiveCommand.Create(() =>
{
walletManager.Wallets.Add(wallet);
#if USE_DIALOG
navigationState.Dialog().Router.NavigationStack.Clear();
#endif
navigationState.Screen().Router.NavigateAndReset.Execute(navigationState.NextView());
});
}
protected WalletViewModel(NavigationStateViewModel navigationState, UiConfig uiConfig, Wallet wallet) : base(navigationState, wallet)
{
Disposables = Disposables is null ? new CompositeDisposable() : throw new NotSupportedException($"Cannot open {GetType().Name} before closing it.");
_actions = new ObservableCollection <ViewModelBase>();
uiConfig = Locator.Current.GetService <Global>().UiConfig;
Observable.Merge(
Observable.FromEventPattern(Wallet.TransactionProcessor, nameof(Wallet.TransactionProcessor.WalletRelevantTransactionProcessed)).Select(_ => Unit.Default))
.Throttle(TimeSpan.FromSeconds(0.1))
.Merge(uiConfig.WhenAnyValue(x => x.PrivacyMode).Select(_ => Unit.Default))
.Merge(Wallet.Synchronizer.WhenAnyValue(x => x.UsdExchangeRate).Select(_ => Unit.Default))
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ =>
{
try
{
var balance = Wallet.Coins.TotalAmount();
Title = $"{WalletName} ({(uiConfig.PrivacyMode ? "#########" : balance.ToString(false, true))} BTC)";
TitleTip = balance.ToUsdString(Wallet.Synchronizer.UsdExchangeRate, uiConfig.PrivacyMode);
}
catch (Exception ex)
{
Logger.LogError(ex);
}
})
.DisposeWith(Disposables);
if (Wallet.KeyManager.IsHardwareWallet || !Wallet.KeyManager.IsWatchOnly)
{
}
if (!Wallet.KeyManager.IsWatchOnly)
{
}
}
