public void CreateWallet(WalletCreateRequest walletCreateRequest)
{
string walletName = walletCreateRequest.WalletName;
string filePath = walletName.GetX1WalletFilepath(C.Network, this.nodeServices.DataFolder);
string passphrase = walletCreateRequest.Passphrase;
if (File.Exists(filePath))
{
throw new InvalidOperationException(
$"A wallet with the name {walletName} already exists at {filePath}!");
}
if (string.IsNullOrWhiteSpace(passphrase))
{
throw new InvalidOperationException("A passphrase is required.");
}
DateTime now = DateTime.UtcNow;
var x1WalletFile = new X1WalletFile
{
WalletGuid = Guid.NewGuid(),
WalletName = walletName,
CoinTicker = C.Network.CoinTicker,
CoinType = C.Network.Consensus.CoinType,
CreatedUtc = now.ToUnixTime(),
ModifiedUtc = now.ToUnixTime(),
LastBackupUtc = null,
Comment = "Your notes here!",
Version = C.WalletKeyFileVersion,
PassphraseChallenge = KeyHelper.GenerateRandomKeyMaterial(passphrase, 32)
.EncryptedPrivateKey,
CurrentPath = filePath
};
byte[] mnemonicBytes = KeyHelper.GetRandom(32);
string bip39Passphrase = walletCreateRequest.Bip39Passphrase?.Trim() ?? "";
Wordlist wl = Wordlist.English;
var mnemonic = new Mnemonic(wl, mnemonicBytes);
byte[] hdSeed = mnemonic.DeriveSeed(bip39Passphrase);
x1WalletFile.HdSeed = VCL.EncryptWithPassphrase(passphrase, hdSeed);
x1WalletFile.HdSeedHasBip39Passphrase = !string.IsNullOrWhiteSpace(bip39Passphrase);
// Create one receive addresses, so that GetUsedReceiveAddresses returns at least one address, even if it is not used in this case.
AddressService.CreateAndInsertNewReceiveAddress("Default address", passphrase, x1WalletFile);
AddressService.CreateAndInsertNewChangeAddresses(passphrase, C.UnusedChangeAddressBuffer, x1WalletFile);
ColdStakingAddressService.EnsureDefaultColdStakingAddress(passphrase, x1WalletFile);
MultiSigAddressService.EnsureDefaultMultisigAddress(passphrase, x1WalletFile);
AddressService.TryUpdateLookAhead(passphrase, x1WalletFile);
x1WalletFile.SaveX1WalletFile(filePath);
X1WalletMetadataFile x1WalletMetadataFile =
x1WalletFile.CreateX1WalletMetadataFile(C.Network.GenesisHash);
string x1WalletMetadataFilename = walletName.GetX1WalletMetaDataFilepath(C.Network, this.nodeServices.DataFolder);
x1WalletMetadataFile.SaveX1WalletMetadataFile(x1WalletMetadataFilename);
}
public async Task <ECCModel> ExecuteAsync([FromBody] RequestObject request)
{
if (AuthKey == null)
{
this.Response.StatusCode = 403;
return(null);
}
try
{
if (IsRequestForPublicKey(request))
{
return(CreatePublicKey());
}
DecryptedRequest decryptedRequest = DecryptRequest(request, this.walletController);
CheckPermissions(decryptedRequest, this.secureApiSettings);
switch (decryptedRequest.Command)
{
case "createWallet":
{
WalletCreateRequest walletCreateRequest = Deserialize <WalletCreateRequest>(decryptedRequest.Payload);
this.walletController.CreateWallet(walletCreateRequest);
return(CreateOk(request));
}
case "loadWallet":
{
LoadWalletResponse loadWalletResponse = this.walletController.LoadWallet();
return(CreateOk(loadWalletResponse, request));
}
case "daemonInfo": // one-time information about the running daemon, includes list of wallet files
{
DaemonInfo daemonStatus = this.walletController.GetDaemonInfo();
return(CreateOk(daemonStatus, request));
}
case "walletInfo": // does not depend on weather a wallet is loaded, but if a wallet is loaded, it includes all wallet info, including balance and staking info when enabled
{
WalletInfo walletInfo = this.walletController.GetWalletInfo();
return(CreateOk(walletInfo, request));
}
case "historyInfo":
{
var historyRequest = Deserialize <HistoryRequest>(decryptedRequest.Payload);
HistoryInfo historyInfo = this.walletController.GetHistoryInfo(historyRequest);
return(CreateOk(historyInfo, request));
}
case "getReceiveAddresses":
{
var getAddressesRequest = Deserialize <GetAddressesRequest>(decryptedRequest.Payload);
GetAddressesResponse getAddressesResponse = this.walletController.GetUsedReceiveAddresses(getAddressesRequest);
return(CreateOk(getAddressesResponse, request));
}
case "createReceiveAddress":
{
var createReceiveAddressRequest = Deserialize <CreateReceiveAddressRequest>(decryptedRequest.Payload);
CreateReceiveAddressResponse addressesModel = this.walletController.CreateReceiveAddress(createReceiveAddressRequest);
return(CreateOk(addressesModel, request));
}
case "estimateFee":
{
var txFeeEstimateRequest = Deserialize <TransactionRequest>(decryptedRequest.Payload);
long fee = this.walletController.EstimateFee(txFeeEstimateRequest);
return(CreateOk(fee, request));
}
case "buildTransaction":
{
var buildTransactionRequest = Deserialize <TransactionRequest>(decryptedRequest.Payload);
TransactionResponse transactionResponse = this.walletController.BuildTransaction(buildTransactionRequest);
return(CreateOk(transactionResponse, request));
}
case "repair":
{
var walletSyncFromDateRequest = Deserialize <RepairRequest>(decryptedRequest.Payload);
this.walletController.Repair(walletSyncFromDateRequest);
return(CreateOk(request));
}
case "importKeys":
{
var importKeysRequest = Deserialize <ImportKeysRequest>(decryptedRequest.Payload);
var importKeysResponse = this.walletController.ImportKeys(importKeysRequest);
return(CreateOk(importKeysResponse, request));
}
case "exportKeys":
{
var exportKeysRequest = Deserialize <ExportKeysRequest>(decryptedRequest.Payload);
var exportKeysResponse = this.walletController.ExportKeys(exportKeysRequest);
return(CreateOk(exportKeysResponse, request));
}
case "startStaking":
{
var startStakingRequest = Deserialize <StartStakingRequest>(decryptedRequest.Payload);
this.walletController.StartStaking(startStakingRequest);
return(CreateOk(request));
}
case "stopStaking":
{
this.walletController.StopStaking();
return(CreateOk(request));
}
default:
throw new NotSupportedException($"The command '{decryptedRequest.Command}' is not supported.");
}
}
catch (Exception e)
{
return(CreateError(e, request));
}
}
public void CreateWallet(WalletCreateRequest walletCreateRequest)
{
this.walletManagerFactory.CreateWallet(walletCreateRequest);
}
