/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="profilesDir"></param>
/// <returns></returns>
public static string LoadEncryptedProfile(HoardID id, string profilesDir)
{
if (!Directory.Exists(profilesDir))
{
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
var profileFiles = Directory.GetFiles(profilesDir, "*.keystore");
if (profileFiles.Length == 0)
{
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
foreach (var fullPath in profileFiles)
{
string fileName = Path.GetFileName(fullPath);
if ((fileName != null) && (fileName != System.String.Empty))
{
string json = File.ReadAllText(fullPath);
var details = JObject.Parse(json);
if (details == null)
{
continue;
}
string address = details["address"].Value <string>();
if (new HoardID(address) == id)
{
return(json);
}
}
}
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
public async Task SignTransaction()
{
HoardID to = new HoardID("0x4bc1EF56d94c766A49153A102096E56fAE2004e1");
var nonce = 324.ToBytesForRLPEncoding();
var gasPrice = 10000000000000.ToBytesForRLPEncoding();
var startGas = 21000.ToBytesForRLPEncoding();
var value = 10000.ToBytesForRLPEncoding();
var data = "".HexToByteArray();
var txEncoded = new List <byte[]>();
txEncoded.Add(RLP.EncodeElement(nonce));
txEncoded.Add(RLP.EncodeElement(gasPrice));
txEncoded.Add(RLP.EncodeElement(startGas));
txEncoded.Add(RLP.EncodeElement(to.ToHexByteArray()));
txEncoded.Add(RLP.EncodeElement(value));
txEncoded.Add(RLP.EncodeElement(data));
var rlpEncodedTransaction = RLP.EncodeList(txEncoded.ToArray());
var user = await signer.RequestProfile(signer.Name + "\0");
var signature = await user.SignTransaction(rlpEncodedTransaction);
var account = Hoard.Utils.Helper.RecoverHoardIdFromTransaction(signature, rlpEncodedTransaction);
Assert.Equal(user.ID, account);
}
public async Task SignMessage()
{
var message = "Hello world";
var byteMsg = message.ToBytesForRLPEncoding();
var signature = await user.SignMessage(byteMsg);
HoardID account = Hoard.Utils.Helper.RecoverHoardIdFromMessage(byteMsg, signature);
Assert.Equal(user.ID, account);
}
/// <inheritdoc/>
public override async Task <BigInteger> GetBalanceOf(HoardID address)
{
var balanceData = await plasmaComm.GetBalanceData(address, contract.Address);
if (balanceData is NFCBalanceData)
{
return((balanceData as NFCBalanceData).TokenIds.Length);
}
return(0);
}
/// <summary>
/// Clear the password from the local storage
/// </summary>
public void DeleteSavedPasswordFor(HoardID userID)
{
var pathToFile = PathToID(userID);
if (!File.Exists(pathToFile))
{
throw new FileNotFoundException("Storage file not found for " + userID);
}
File.Delete(pathToFile);
}
public override async Task <Profile> RequestProfile(string name)
{
uint accountIndex = ProfileNameToIndex(name);
var keyPath = new KeyPath(DerivationPath).Derive(accountIndex);
var output = await SendRequestAsync(EthGetAddress.Request(keyPath.Indices));
var address = new HoardID(EthGetAddress.GetAddress(output));
return(new HDWalletProfile(name, address, keyPath.Indices, this));
}
/// <summary>
/// Returns HRD balance of given account
/// </summary>
/// <param name="account">account to query</param>
/// <returns></returns>
public async Task <BigInteger> GetHRDBalance(HoardID account)
{
string hrdAddress = await GetHRDAddress();
if (hrdAddress != null)
{
hrdAddress.RemoveHexPrefix();
HoardTokenContract hrdContract = new HoardTokenContract(web, hrdAddress);
return(await hrdContract.GetBalanceOf(account));
}
return(new BigInteger(0));
}
/// <summary>
/// Returns UTXO of given account, currency and amount
/// </summary>
/// <param name="account">account to query</param>
/// <param name="currency">currency to query</param>
/// <param name="data">data to query (amount or token id)</param>
/// <returns></returns>
public async Task <UTXOData> GetUtxo(HoardID account, string currency, BigInteger data)
{
var utxos = await GetUtxos(account);
foreach (var utxo in utxos)
{
if (utxo.Currency == currency.EnsureHexPrefix().ToLower() && utxo.Data == data)
{
return(utxo);
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="encryptedData"></param>
/// <returns></returns>
public string DecryptPassword(HoardID id, EncryptedData encryptedData)
{
try
{
byte[] decryptionKey = GenerateKey(ProvideEncryptionPhrase());
byte[] decrypted = Helper.AESDecrypt(decryptionKey, WhisperService.HexStringToByteArray(encryptedData.pswd), ProvideIV(), 256);
return(Encoding.UTF8.GetString(decrypted));
}
catch (Exception e)
{
throw new HoardException("Can't decrypt password for id " + id.ToString(), e);
}
}
public Task <string> RequestInput(string name, HoardID id, eUserInputType type, string description)
{
switch (type)
{
case eUserInputType.kLogin:
return(Task.Run(() => UserName));
case eUserInputType.kPassword:
return(Task.Run(() => EncryptedPassword));
default:
throw new System.NotImplementedException("Decrypted credentials can't provide information about " + type.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="type"></param>
/// <param name="description"></param>
/// <returns></returns>
public async Task <string> RequestInput(string name, HoardID id, eUserInputType type, string description)
{
await Task.Yield();
if (type == eUserInputType.kLogin)
{
return("TestUser");
}
else if (type == eUserInputType.kPassword)
{
return("dev");
}
return(null);
}
public async Task EncryptAndSaveCredentials(HoardID userID, IUserInputProvider credentials)
{
var pathToFile = PathToID(userID);
var pass = await credentials.RequestInput("Password", userID, eUserInputType.kPassword, "");
var encrypted = EncryptPassword(userID, pass);
using (var file = new StreamWriter(pathToFile, true))
{
var converted = await Task.Run(() => JsonConvert.SerializeObject(encrypted));
await file.WriteAsync(converted);
}
}
public override async Task<Profile> RequestProfile(string name)
{
uint accountIndex = ProfileNameToIndex(name);
var keyPath = new KeyPath(DerivationPath).Derive(accountIndex);
byte[] derivationData = keyPath.ToBytes();
var output = await SendRequestAsync(EthGetAddress.Request(derivationData));
if(IsSuccess(output.StatusCode))
{
var address = new HoardID(EthGetAddress.GetAddress(output.Data));
return new HDWalletProfile(name, address, derivationData, this);
}
throw new Exception("HD wallet returned error: " + output.StatusCode);
}
/// <summary>
/// Returns UTXOs of given account in given currency
/// </summary>
/// <param name="account">account to query</param>
/// <param name="currency">currency to query</param>
/// <returns></returns>
public async Task <UTXOData[]> GetUtxos(HoardID account, string currency)
{
var utxos = await GetUtxos(account);
var result = new List <UTXOData>();
foreach (var utxo in utxos)
{
if (utxo.Currency == currency.EnsureHexPrefix().ToLower())
{
result.Add(utxo);
}
}
return(result.ToArray());
}
/// <inheritdoc/>
public override async Task <GameItem[]> GetGameItems(HoardID address)
{
var items = new List <GameItem>();
var balanceData = await plasmaComm.GetBalanceData(address, contract.Address);
if (balanceData is FCBalanceData)
{
string symbol = await contract.GetSymbol();
string state = (await(contract as ERC223GameItemContract).GetTokenState()).ToHex(true);
ERC223GameItemContract.Metadata meta = new ERC223GameItemContract.Metadata(contract.Address, (balanceData as FCBalanceData).Amount);
items.Add(new GameItem(game, symbol, meta));
}
return(items.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="type"></param>
/// <param name="description"></param>
/// <returns></returns>
public async Task <string> RequestInput(string name, HoardID id, eUserInputType type, string description)
{
await Task.Yield();
if (type == eUserInputType.kPIN)
{
var pinWindow = new PINWindow();
pinWindow.Text = description;
pinWindow.ShowDialog();
pinWindow.PINEnteredEvent.WaitOne();
pinWindow.PINEnteredEvent.Reset();
pinWindow.Dispose();
return(pinWindow.PINValue);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="password"></param>
/// <returns></returns>
public EncryptedData EncryptPassword(HoardID id, string password)
{
try
{
byte[] encryptionKey = GenerateKey(ProvideEncryptionPhrase());
byte[] _iv = ProvideIV();
byte[] encryptedData = Helper.AESEncrypt(encryptionKey, Encoding.UTF8.GetBytes(password), _iv, 256);
string hashedId = Helper.Keccak256HexHashString(id.ToString());
EncryptedData data = new EncryptedData();
data.pswd = BitConverter.ToString(encryptedData).Replace("-", string.Empty);
return(data);
}
catch (Exception e)
{
throw new HoardException("Can't encrypt password for id " + id.ToString(), e);
}
}
/// <summary>
/// Decrypts the password
/// </summary>
public async Task <string> DecryptPasswordFor(HoardID userID)
{
var pathToFile = PathToID(userID);
if (!File.Exists(pathToFile))
{
throw new FileNotFoundException("Storage file not found for " + userID);
}
using (var file = new StreamReader(pathToFile, true))
{
var buffer = await file.ReadToEndAsync();
var encrypted = JsonConvert.DeserializeObject <EncryptedData>(buffer);
var decrypted = DecryptPassword(userID, encrypted);
return(decrypted);
}
}
/// <summary>
///
/// </summary>
/// <param name="userInputProvider"></param>
/// <param name="id"></param>
/// <param name="profilesDir"></param>
/// <param name="passwordNeeded"></param>
/// <returns></returns>
public static async Task DeleteProfile(IUserInputProvider userInputProvider, HoardID id, string profilesDir, bool passwordNeeded)
{
if (!Directory.Exists(profilesDir))
{
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
string[] files = Directory.GetFiles(profilesDir, "*.keystore");
var keyStoreService = new Nethereum.KeyStore.KeyStoreService();
foreach (string file in files)
{
StreamReader jsonReader = new StreamReader(file);
JObject jobj = JObject.Parse(jsonReader.ReadToEnd());
jsonReader.Close();
JToken valueAddress;
if (jobj.TryGetValue("address", out valueAddress))
{
HoardID actualId = new HoardID(valueAddress.Value <string>());
if (id == actualId)
{
Nethereum.Signer.EthECKey key = null;
if (passwordNeeded)
{
string password = await userInputProvider.RequestInput(null, id, eUserInputType.kPassword, valueAddress.Value <string>());
try
{
key = new Nethereum.Signer.EthECKey(keyStoreService.DecryptKeyStoreFromJson(password, jobj.ToString()), true);
}
catch (Exception e)
{
throw new HoardException("Incorrect password", e);
}
}
File.Delete(file);
return;
}
}
}
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
private async Task <GameItem[]> GetItemsClientRequest(HoardID accountId = null, string itemType = null, ulong?page = null, ulong?itemsPerPage = null)
{
var request = new RestRequest("items/", Method.GET);
if (accountId != null)
{
request.AddQueryParameter("owner_address", accountId.ToString().EnsureHexPrefix());
}
if (itemType != null)
{
request.AddQueryParameter("item_type", itemType);
}
if (page.HasValue)
{
request.AddQueryParameter("page", page.Value.ToString());
if (itemsPerPage != null)
{
request.AddQueryParameter("per_page", itemsPerPage.Value.ToString());
}
}
var response = await Client.ExecuteTaskAsync(request).ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var gameItems = new List <GameItem>();
var result = JArray.Parse(response.Content);
foreach (var item in result.Children <JObject>())
{
gameItems.AddRange(JsonConvert.DeserializeObject <List <GameItem> >(
item.GetValue("items").ToString(),
new JsonConverter[] { new GameItemsConverter() }
));
}
return(gameItems.ToArray());
}
return(null);
}
/// <summary>
/// Returns balance of given account and currency
/// </summary>
/// <param name="account">account to query</param>
/// <param name="currency">currency to query</param>
/// <returns></returns>
protected async Task <BigInteger> GetBalance(HoardID account, string currency)
{
var balances = await GetBalanceData(account);
var utxoData = balances.FirstOrDefault(x => x.Currency == currency.EnsureHexPrefix().ToLower());
if (utxoData != null)
{
if (utxoData is FCBalanceData)
{
return((utxoData as FCBalanceData).Amount);
}
if (utxoData is NFCBalanceData)
{
return((utxoData as NFCBalanceData).TokenIds.Length);
}
}
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="oldPassword"></param>
/// <param name="newPassword"></param>
/// <param name="profilesDir"></param>
/// <returns></returns>
public static string ChangePassword(HoardID id, string oldPassword, string newPassword, string profilesDir)
{
if (!Directory.Exists(profilesDir))
{
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
string[] files = Directory.GetFiles(profilesDir, "*.keystore");
var keyStoreService = new Nethereum.KeyStore.KeyStoreService();
foreach (string file in files)
{
StreamReader jsonReader = new StreamReader(file);
JObject jobj = JObject.Parse(jsonReader.ReadToEnd());
jsonReader.Close();
JToken valueAddress;
JToken name;
if (jobj.TryGetValue("address", out valueAddress) && jobj.TryGetValue("name", out name))
{
HoardID actualId = new HoardID(valueAddress.Value <string>());
if (id == actualId)
{
string newFile = null;
try
{
var key = new Nethereum.Signer.EthECKey(keyStoreService.DecryptKeyStoreFromJson(oldPassword, jobj.ToString()), true);
newFile = CreateAccountKeyStoreFile(key, newPassword, name.Value <string>(), profilesDir);
}
catch (Exception e)
{
throw new HoardException("Incorrect password", e);
}
if (newFile != null)
{
File.Delete(file);
}
return(newFile);
}
}
}
throw new HoardException(string.Format("Profile doesn't exists: {0}", id.ToString()));
}
private async Task <ulong> GetItemsAmountClientRequest(HoardID accountId, string itemType = null)
{
var request = new RestRequest("items/balance/", Method.GET);
request.AddQueryParameter("owner_address", accountId.ToString().EnsureHexPrefix());
if (itemType != null)
{
request.AddQueryParameter("item_type", itemType);
}
var response = await Client.ExecuteTaskAsync(request).ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var result = JObject.Parse(response.Content);
return(result.GetValue("balance").Value <ulong>());
}
return(0);
}
/// <inheritdoc/>
public override async Task <GameItem[]> GetGameItems(HoardID address)
{
var items = new List <GameItem>();
var balanceData = await plasmaComm.GetBalanceData(address, contract.Address);
if (balanceData is NFCBalanceData)
{
string symbol = await contract.GetSymbol();
foreach (var tokenId in (balanceData as NFCBalanceData).TokenIds)
{
ERC721GameItemContract.Metadata meta = new ERC721GameItemContract.Metadata(contract.Address, tokenId);
GameItem gameItem = new GameItem(game, symbol, meta);
gameItem.State = await plasmaComm.GetTokenState(contract.Address, tokenId);
items.Add(gameItem);
}
}
return(items.ToArray());
}
/// <inheritdoc/>
public async Task <BigInteger> GetBalance(HoardID account)
{
var ver = new Nethereum.RPC.Eth.EthGetBalance(web.Client);
return((await ver.SendRequestAsync(account)).Value);
}
public HDWalletProfile(string name, HoardID id, uint[] indices, EthTrezorWallet wallet)
: base(name, id)
{
Wallet = wallet;
DerivationIndices = indices;
}
private string PathToID(HoardID userID) => Path.Combine(StoragePath, userID.ToString()) + ".hse";
/// <summary> /// Returns total amount of items given account owns /// </summary> /// <param name="address">Account address of the owner</param> /// <returns></returns> public abstract Task <BigInteger> GetBalanceOf(HoardID address);
/// <summary> /// Has the user it's password saved? /// </summary> public bool HasPasswordSaved(HoardID userID) => File.Exists(PathToID(userID));
public HDWalletProfile(string name, HoardID id, byte[] data, EthLedgerWallet wallet)
:base(name, id)
{
Wallet = wallet;
DerivationData = data;
}
