private void ValidateWalletName(IValidationErrors errors, WalletManager walletManager, string walletName)
{
string walletFilePath = Path.Combine(walletManager.WalletDirectories.WalletsDir, $"{walletName}.json");
if (string.IsNullOrEmpty(walletName))
{
return;
}
if (walletName.IsTrimmable())
{
errors.Add(ErrorSeverity.Error, "Leading and trailing white spaces are not allowed!");
return;
}
if (File.Exists(walletFilePath))
{
errors.Add(ErrorSeverity.Error,
$"A wallet named {walletName} already exists. Please try a different name.");
return;
}
if (!WalletGenerator.ValidateWalletName(walletName))
{
errors.Add(ErrorSeverity.Error, "Selected Wallet is not valid. Please try a different name.");
}
}
public object CreateWallet(string walletName, string password)
{
var walletGenerator = new WalletGenerator(Global.WalletsDir, Global.Network);
walletGenerator.TipHeight = Global.BitcoinStore.SmartHeaderChain.TipHeight;
var(keyManager, mnemonic) = walletGenerator.GenerateWallet(walletName, password);
keyManager.ToFile();
return(mnemonic.ToString());
}
public void Init()
{
_wallet = WalletGenerator.GenerateMockWallet();
// for encryption and decryption tests
_key = "238085A3C30982B6DBE1F6F5CEFA4584";
_path = WalletFileTools.GetWalletFilePath(_wallet.Id);
_recoverypath = WalletFileTools.GetWalletRecoveryFilePath(_wallet.Id);
}
public void GenerateNewWallet()
{
IWallet result = WalletGenerator.GenerateNewWallet(_wallet.Id, _wallet.Name, _wallet.MasterKeyWIF, _wallet.NetworkChoice, _wallet.Description);
Assert.AreEqual(_wallet.Id, result.Id);
Assert.AreEqual(_wallet.Name, result.Name);
Assert.AreEqual(_wallet.Description, result.Description);
Assert.AreEqual(_wallet.MasterKeyWIF, result.MasterKeyWIF);
Assert.AreEqual(_wallet.NetworkChoice, result.NetworkChoice);
}
public AddWalletPageViewModel(
LegalDocuments legalDocuments,
WalletManager walletManager,
BitcoinStore store,
Network network)
{
Title = "Add Wallet";
SelectionMode = NavBarItemSelectionMode.Button;
_legalDocuments = legalDocuments;
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, network, walletManager)); });
ImportWalletCommand = ReactiveCommand.Create(() => new ImportWalletViewModel(WalletName, walletManager));
ConnectHardwareWalletCommand = ReactiveCommand.Create(() =>
{
Navigate().To(new ConnectHardwareWalletViewModel(WalletName, network, walletManager));
});
CreateWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var result = await NavigateDialog(
new EnterPasswordViewModel("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));
});
Navigate().To(new RecoveryWordsViewModel(km, mnemonic, walletManager), NavigationMode.Clear);
IsBusy = false;
}
});
this.ValidateProperty(x => x.WalletName, errors => ValidateWalletName(errors, walletManager, WalletName));
}
public void GenerateWalletFail()
{
string badMasterKeyWIF = "5KRYM46bcstckRxtdDdBZTshjxtpWtTNBDXKcNWC7yjiGhnuBzV";
Hashtable walletData = new Hashtable();
walletData.Add("id", _wallet.Id);
walletData.Add("name", _wallet.Name);
walletData.Add("description", _wallet.Description);
walletData.Add("masterkey", badMasterKeyWIF);
walletData.Add("network", _wallet.NetworkChoice.ToString());
Assert.Throws <FormatException>(() => WalletGenerator.GenerateWalletFromFile(walletData));
}
private void DoNextCommand()
{
try
{
var walletGenerator = new WalletGenerator(Global.WalletManager.WalletDirectories.WalletsDir, Global.Network);
walletGenerator.TipHeight = Global.BitcoinStore.SmartHeaderChain.TipHeight;
var(km, mnemonic) = walletGenerator.GenerateWallet(WalletName, Password);
Owner.CurrentView = new GenerateWalletSuccessViewModel(Owner, km, mnemonic);
}
catch (Exception ex)
{
Logger.LogError(ex);
NotificationHelpers.Error(ex.ToUserFriendlyString());
}
}
public void CanGenerateValidPrivateKey()
{
var network = Network.Main;
var generator = new WalletGenerator(network);
var generatedWallet = generator.Generate();
var key = Key.Parse(generatedWallet.PrivateKey, network);
var addressFromKey = key.PubKey.WitHash.ScriptPubKey.Hash.GetAddress(network).ToString();
Assert.True(generatedWallet.Address == addressFromKey);
Assert.True(generatedWallet.PubKey == key.PubKey.ToHex());
Assert.True(generatedWallet.PrivateKey == key.ToString(network));
}
public void GenerateWallet()
{
Hashtable walletData = new Hashtable();
walletData.Add("id", _wallet.Id);
walletData.Add("name", _wallet.Name);
walletData.Add("description", _wallet.Description);
walletData.Add("masterkey", _wallet.MasterKeyWIF);
walletData.Add("network", _wallet.NetworkChoice.ToString());
IWallet result = WalletGenerator.GenerateWalletFromFile(walletData);
Assert.AreEqual(result.Id, _wallet.Id);
Assert.AreEqual(result.Name, _wallet.Name);
Assert.AreEqual(result.Description, _wallet.Description);
Assert.AreEqual(result.MasterKeyWIF, _wallet.MasterKeyWIF);
Assert.AreEqual(result.NetworkChoice, _wallet.NetworkChoice);
}
public override Task <int> InvokeAsync(IEnumerable <string> args)
{
var error = false;
try
{
var extra = Options.Parse(args);
if (ShowHelp)
{
Options.WriteOptionDescriptions(CommandSet.Out);
}
else if (string.IsNullOrWhiteSpace(WalletName) && string.IsNullOrWhiteSpace(EncryptedSecret))
{
Console.WriteLine("Missing required argument `--wallet=WalletName`.");
Console.WriteLine("Use `findpassword --help` for details.");
error = true;
}
else if (!PasswordFinder.Charsets.ContainsKey(Language))
{
Console.WriteLine($"`{Language}` is not available language try with `en, es, pt, it or fr`.");
Console.WriteLine("Use `findpassword --help` for details.");
error = true;
}
else if (!string.IsNullOrWhiteSpace(WalletName))
{
KeyManager km = WalletGenerator.TryGetKeymanagerFromWalletName(WalletName);
if (km is null)
{
error = true;
}
PasswordFinder.Find(km.EncryptedSecret.ToWif(), Language, UseNumbers, UseSymbols);
}
else if (!string.IsNullOrWhiteSpace(EncryptedSecret))
{
PasswordFinder.Find(EncryptedSecret, Language, UseNumbers, UseSymbols);
}
}
catch (Exception)
{
Console.WriteLine($"There was a problem interpreting the command, please review it.");
error = true;
}
Environment.Exit(error ? 1 : 0);
return(Task.FromResult(0));
}
public AddWalletPageViewModel(NavigationStateViewModel navigationState, WalletManager walletManager,
BitcoinStore store, Network network) : base(navigationState, NavigationTarget.DialogScreen)
{
Title = "Add Wallet";
this.WhenAnyValue(x => x.WalletName)
.Select(x => !string.IsNullOrWhiteSpace(x))
.Subscribe(x => OptionsEnabled = x && !Validations.Any);
RecoverWalletCommand = ReactiveCommand.CreateFromTask(async() =>
{
NavigateTo(new RecoverWalletViewModel(navigationState, WalletName, network, walletManager), NavigationTarget.DialogScreen);
});
CreateWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var enterPassword = new EnterPasswordViewModel(
navigationState,
NavigationTarget.DialogScreen,
"Type the password of the wallet and click Continue.");
NavigateTo(enterPassword, NavigationTarget.DialogScreen);
var result = await enterPassword.GetDialogResultAsync();
if (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));
});
NavigateTo(new RecoveryWordsViewModel(navigationState, km, mnemonic, walletManager), NavigationTarget.DialogScreen, true);
}
public void CanGenerateValidPrivateKey()
{
PrepareNetworks.EnsureLiteCoinPrepared();
var network = Network.TestNet;
var generator = new WalletGenerator(network);
var generatedWallet = generator.Generate();
var key = Key.Parse(generatedWallet.PrivateKey, network);
var addressFromKey = key.PubKey.GetAddress(network).ToString();
var btcAddress = BitcoinAddress.Create(generatedWallet.Address, network);
Assert.True(generatedWallet.Address == addressFromKey);
Assert.True(generatedWallet.Address == btcAddress.ToString());
Assert.True(generatedWallet.PrivateKey == key.ToString(network));
}
private async Task OnCreateWallet(WalletManager walletManager, BitcoinStore store, Network network)
{
var dialogResult = await NavigateDialog(
new CreatePasswordDialogViewModel("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));
}
}
private async Task OnCreateWalletAsync(string walletName)
{
var dialogResult = await NavigateDialogAsync(
new CreatePasswordDialogViewModel("Type the password of the wallet and click Continue.", enableEmpty : true, enableCancel : Services.WalletManager.HasWallet()));
if (dialogResult.Result is { } password)
{
var(km, mnemonic) = await Task.Run(
() =>
{
var walletGenerator = new WalletGenerator(
Services.WalletManager.WalletDirectories.WalletsDir,
Services.WalletManager.Network)
{
TipHeight = Services.BitcoinStore.SmartHeaderChain.TipHeight
};
return(walletGenerator.GenerateWallet(walletName, password));
});
Navigate().To(new RecoveryWordsViewModel(km, mnemonic));
}
}
public AddWalletPageViewModel(IScreen screen, WalletManager walletManager, BitcoinStore store, Network network) : base(screen)
{
Title = "Add Wallet";
this.WhenAnyValue(x => x.WalletName)
.Select(x => !string.IsNullOrWhiteSpace(x))
.Subscribe(x => OptionsEnabled = x);
RecoverWalletCommand = ReactiveCommand.Create(() => screen.Router.Navigate.Execute(new RecoveryPageViewModel(screen)));
CreateWalletCommand = ReactiveCommand.CreateFromTask(
async() =>
{
var result = await PasswordInteraction.Handle("").ToTask();
if (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));
});
await screen.Router.Navigate.Execute(
new RecoveryWordsViewModel(screen, km, mnemonic, walletManager));
}
});
PasswordInteraction = new Interaction <string, string?>();
PasswordInteraction.RegisterHandler(
async interaction => interaction.SetOutput(await new EnterPasswordViewModel().ShowDialogAsync()));
}
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);
}
public void Init()
{
_wallet = WalletGenerator.GenerateMockWallet();
_wallet.Initialize();
}
public void GenerateNewWalletFail()
{
string badMasterKeyWIF = "5KRYM46bcstckRxtdDdBZTshjxtpWtTNBDXKcNWC7yjiGhnuBzV";
Assert.Throws <FormatException>(() => WalletGenerator.GenerateNewWallet(_wallet.Id, _wallet.Name, badMasterKeyWIF, _wallet.NetworkChoice, _wallet.Description));
}
public void Init()
{
var masterKeyWIF = _masterKey.GetWif(_networkChoice).ToString();
_wallet = WalletGenerator.GenerateNewWallet(_id, _name, masterKeyWIF, _networkChoice, _description);
}
