public static walletManagement Load(string password, string walletFilePath)
{
if (!File.Exists(walletFilePath))
{
throw new ArgumentException($"No wallet file found at {walletFilePath}");
}
var walletFileRawContent = walletFileSerializer.Deserialize(walletFilePath);
var encryptedBitcoinPrivateKeyString = walletFileRawContent.EncryptedSeed;
var chainCodeString = walletFileRawContent.ChainCode;
var chainCode = Convert.FromBase64String(chainCodeString);
Network network;
var networkString = walletFileRawContent.Network;
network = networkString == Network.Main.ToString() ? Network.Main : Network.TestNet;
var wallet = new walletManagement(password, walletFilePath, network);
var privateKey = Key.Parse(encryptedBitcoinPrivateKeyString, password, wallet.Network);
var seedExtKey = new ExtKey(privateKey, chainCode);
wallet.SetSeed(seedExtKey);
return(wallet);
}
/// <summary>
/// </summary>
/// <param name="mnemonic"></param>
/// <param name="password"></param>
/// <param name="walletFilePath"></param>
/// <param name="network"></param>
/// <param name="creationTime">if null then will default to EarliestPossibleCreationTime</param>
/// <returns></returns>
public static walletManagement Recover(Mnemonic mnemonic, string password, string walletFilePath,
Network network)
{
var wallet = new walletManagement(password, walletFilePath, network, mnemonic);
var addresses = new Addresses();
addresses.change = new List <string>();
addresses.receiving = new List <string>();
foreach (var addr in wallet.GetFirstNAddresses(10, HdPathType.Change))
{
addresses.change.Add(addr.ToString());
}
foreach (var addr in wallet.GetFirstNAddresses(10, HdPathType.Receive))
{
addresses.receiving.Add(addr.ToString());
}
wallet.Save(password, walletFilePath, network, addresses);
return(wallet);
}
public walletManagement(walletManagement wallet)
{
Network = wallet.Network;
ExtKey = wallet.ExtKey;
WalletFilePath = wallet.WalletFilePath;
}
public static void Serialize(walletManagement wallet, int minUnusedKeys = 4)
{
if (MainWindow.CheckForInternetConnection())
{
var walletData = JsonConvert.DeserializeObject <Data>(
File.ReadAllText(walletFileSerializer.Deserialize(wallet.WalletFilePath).walletTransactionsPath));
var addresses = walletData.addresses.change.ToList();
addresses.AddRange(walletData.addresses.receiving);
explorer = new BlockExplorer();
var addressesData = explorer.GetMultiAddressAsync(addresses).Result;
foreach (var tx in addressesData.Transactions)
{
if (walletData.txData.Keys.Contains(tx.Hash))
{
continue;
}
var InputsPerAddress = new List <Inputs>();
var OutputsPerAddress = new List <Outputs>();
tx.Inputs.ToList().ForEach(inp =>
{
InputsPerAddress.Add(new Inputs
{
address = inp.PreviousOutput.Address,
index = inp.PreviousOutput.N,
value = inp.PreviousOutput.Value.GetBtc()
});
if (walletData.addresses.receiving.Contains(inp.PreviousOutput.Address))
{
walletData.usedAddresses.Add(inp.PreviousOutput.Address);
}
if (walletData.addresses.change.Contains(inp.PreviousOutput.Address))
{
walletData.usedAddresses.Add(inp.PreviousOutput.Address);
}
});
tx.Outputs.ToList().ForEach(outp =>
{
OutputsPerAddress.Add(new Outputs
{
address = outp.Address,
index = outp.N,
value = outp.Value.GetBtc()
});
if (walletData.addresses.receiving.Contains(outp.Address))
{
walletData.usedAddresses.Add(outp.Address);
}
if (walletData.addresses.change.Contains(outp.Address))
{
walletData.usedAddresses.Add(outp.Address);
}
});
walletData.txData.Add(tx.Hash,
new TxData
{
hash = tx.Hash,
date = tx.Time,
lockTime = tx.BlockHeight,
size = tx.Size,
fee = NB.Money.Satoshis(tx.Fee).ToDecimal(NB.MoneyUnit.BTC),
value = NB.Money.Satoshis(tx.Result).ToDecimal(NB.MoneyUnit.BTC),
inputs = InputsPerAddress,
outputs = OutputsPerAddress
});
}
var unusedreceivingKeysCount = walletData.addresses.receiving.Count;
walletData.addresses.receiving.ForEach(key =>
{
if (walletData.usedAddresses.Contains(key))
{
unusedreceivingKeysCount--;
}
});
if (unusedreceivingKeysCount < minUnusedKeys)
{
var receivingKeysStartIndex = walletData.addresses.receiving.Count;
for (var i = 0; i < minUnusedKeys; i++)
{
walletData.addresses.receiving.Add(wallet
.GetAddress(receivingKeysStartIndex++, HdPathType.Receive).ToString());
}
}
var unusedchangeKeysCount = walletData.addresses.change.Count;
walletData.addresses.change.ForEach(key =>
{
if (walletData.usedAddresses.Contains(key))
{
unusedreceivingKeysCount--;
}
});
if (unusedchangeKeysCount < minUnusedKeys)
{
var changeKeysStartIndex = walletData.addresses.change.Count;
for (var i = 0; i < minUnusedKeys; i++)
{
walletData.addresses.receiving.Add(wallet.GetAddress(changeKeysStartIndex++, HdPathType.Change)
.ToString());
}
}
walletData.unspent_Outputs = new List <Unspent_Outputs>();
var unspentChange = explorer.GetUnspentOutputsAsync(walletData.addresses.change).Result;
foreach (var outp in unspentChange)
{
var existsOuts = walletData.unspent_Outputs.FirstOrDefault(x =>
x.hash == outp.tx_hash_big_endian && x.confirmations == outp.Confirmations &&
x.index == outp.N);
if (existsOuts == null)
{
var tx = walletData.txData.FirstOrDefault(x => x.Key == outp.tx_hash_big_endian);
tx.Value.outputs.ForEach(output =>
{
if (output.index == outp.N)
{
walletData.unspent_Outputs.Add(new Unspent_Outputs
{
hash = outp.tx_hash_big_endian,
address = output.address,
confirmations = outp.Confirmations,
index = outp.N,
value = outp.Value.GetBtc()
});
}
});
}
}
var unspentReceiving = explorer.GetUnspentOutputsAsync(walletData.addresses.receiving).Result;
foreach (var outp in unspentReceiving)
{
var existsOuts = walletData.unspent_Outputs.FirstOrDefault(x =>
x.hash == outp.tx_hash_big_endian && x.confirmations == outp.Confirmations &&
x.index == outp.N);
if (existsOuts == null)
{
var tx = walletData.txData.FirstOrDefault(x => x.Key == outp.tx_hash_big_endian);
tx.Value.outputs.ForEach(output =>
{
if (output.index == outp.N)
{
walletData.unspent_Outputs.Add(new Unspent_Outputs
{
hash = outp.tx_hash_big_endian,
address = output.address,
confirmations = outp.Confirmations,
index = outp.N,
value = outp.Value.GetBtc()
});
}
});
}
}
foreach (var tx in walletData.txData.Values)
{
if (tx.value > 0)
{
foreach (var outp in tx.outputs)
{
if (walletData.usedAddresses.Contains(outp.address))
{
tx.address = outp.address;
break;
}
}
}
else
{
foreach (var inp in tx.inputs)
{
if (walletData.usedAddresses.Contains(inp.address))
{
tx.address = inp.address;
break;
}
}
}
}
File.WriteAllText(walletFileSerializer.Deserialize(wallet.WalletFilePath).walletTransactionsPath,
JsonConvert.SerializeObject(walletData));
}
}
