private void RefreshBalance()
{
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.GetUnconfirmedBalance().ContinueWith((r) =>
{
try
{
var balance = (int)r.Result;
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.Balance = balance;
});
}
catch (AggregateException ex)
{
}
});
}
private void DisplayBlock(object sender, BlockEventArgs e)
{
var walletStore = WalletStore.Instance();
var flyout = new BlockFlyoutPage(e.Data, walletStore.GetAuthenticatedWallet().Network);
MainWindowStore.Instance().DisplayFlyout(flyout, Position.Right, 400);
}
private void RefreshNbBlocks()
{
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.GetBlockCount().ContinueWith((r) =>
{
try
{
var nb = r.Result;
Application.Current.Dispatcher.Invoke(() =>
{
WalletPageStore.Instance().NbBlocks = nb;
_viewModel.NbBlocks = nb;
});
}
catch (AggregateException ex)
{
}
});
}
private void ConnectP2PNetwork(object sender, EventArgs e)
{
_nodeLauncher.RefreshBlockChain();
_timer = new Timer(TimerElapsed, _autoEvent, REFRESH_INFORMATION_INTERVAL, REFRESH_INFORMATION_INTERVAL);
_viewModel.IsConnected = true;
WalletStore.Instance().Switch(_viewModel.IsTestNetChecked ? Networks.TestNet : Networks.MainNet);
}
private void Init()
{
var walletStore = WalletStore.Instance();
var rpcClient = new RpcClient(walletStore.GetAuthenticatedWallet().Network);
Application.Current.Dispatcher.Invoke(() => {
_viewModel.Raws.Clear();
});
rpcClient.GetRawMemPool(true).ContinueWith((r) =>
{
try
{
var result = r.Result;
foreach (var rawMemPool in result)
{
var record = new RawMemPoolViewModel
{
Fee = rawMemPool.Fee,
Time = rawMemPool.Time,
TxId = rawMemPool.TxId,
AncestorCount = rawMemPool.AncestorCount,
DescendantCount = rawMemPool.DescendantCount
};
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.Raws.Add(record);
});
}
}
catch (AggregateException ex)
{
}
});
}
private void Connect(object sender, EventArgs e)
{
if (_viewModel.SelectedWallet == null)
{
return;
}
_viewModel.ToggleLoading();
_walletRepository.Get(_viewModel.SelectedWallet.Name, _viewModel.Password).ContinueWith((r) =>
{
try
{
var result = r.Result;
WalletStore.Instance().SetAuthenticatedWallet(r.Result);
WalletStore.Instance().SetPassword(_viewModel.Password);
Application.Current.Dispatcher.Invoke(() =>
{
NavigationService.Navigate(_walletPage);
});
}
catch (AggregateException)
{
MainWindowStore.Instance().DisplayError("Cannot connect to the wallet");
}
finally
{
_viewModel.ToggleLoading();
}
});
}
private JObject GetUnconfirmedBalance(string id, JObject response)
{
var transactions = MemoryPool.Instance().GetTransactions();
var wallet = WalletStore.Instance().GetAuthenticatedWallet();
if (wallet == null)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_WALLET_NOT_FOUND, "No authenticated wallet"));
}
long unconfirmedBalance = 0;
if (wallet.Addresses != null)
{
var bcAddrs = wallet.Addresses.Select(addr => BlockChainAddress.Deserialize(addr.Hash));
foreach (var memTx in transactions)
{
var mBcTx = memTx.Transaction as BcBaseTransaction;
if (mBcTx == null)
{
continue;
}
var balance = _transactionHelper.CalculateBalance(mBcTx, bcAddrs, _network);
unconfirmedBalance += balance;
}
}
response["result"] = unconfirmedBalance;
return(response);
}
private void RefreshMoney()
{
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.GetUnspentTransactions(new GetUnspentTransactionsParameter()).ContinueWith((r) =>
{
lock (_lock)
{
try
{
var unspentTransactions = r.Result.Where(t => t.Spendable);
if (unspentTransactions != null)
{
Application.Current.Dispatcher.Invoke(() =>
{
var selectedTransaction = _viewModel.SelectedTransaction;
var transactionsToUpdate = _viewModel.Transactions.Where(tvm => unspentTransactions.Any(utxo => tvm.TxId == utxo.TxId && tvm.Vout == utxo.Vout)).ToList();
var transactionsToRemove = _viewModel.Transactions.Where(tvm => unspentTransactions.All(utxo => tvm.TxId != utxo.TxId && tvm.Vout != utxo.Vout)).ToList();
foreach (var txUpdate in transactionsToUpdate)
{
var tr = unspentTransactions.First(u => u.TxId == txUpdate.TxId && u.Vout == txUpdate.Vout);
txUpdate.Amount = tr.Amount;
txUpdate.DisplayName = string.Format("{0} : {1}", tr.Amount, tr.TxId);
}
foreach (var txRemove in transactionsToRemove)
{
_viewModel.Transactions.Remove(txRemove);
}
var transactionsToAdd = unspentTransactions.Where(utxo => _viewModel.Transactions.All(tvm => tvm.TxId != utxo.TxId && tvm.Vout != utxo.Vout)).ToList();
foreach (var transactionToAdd in transactionsToAdd)
{
var txVm = new TransactionViewModel(transactionToAdd.TxId, transactionToAdd.Vout, transactionToAdd.Amount, transactionToAdd.Address, transactionToAdd.Confirmations);
_viewModel.Transactions.Add(txVm);
}
_viewModel.Amount = unspentTransactions.Where(t => t.Confirmations > 0).Sum(t => t.Amount);
});
}
}
catch (AggregateException ex)
{
// TODO : Display loading message.
}
}
});
}
private void ListenSmartContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (_viewModel.SelectedSolidityContract == null)
{
MainWindowStore.Instance().DisplayError("Contract must be selected");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.AddFilter(_viewModel.SelectedSolidityContract.Address.FromHexString()).ContinueWith((t) =>
{
try
{
var addFilterResult = t.Result;
_solidityFilterRepository.Add(_viewModel.SelectedSolidityContract.Address, t.Result.ToHexString()).ContinueWith((s) =>
{
if (!s.Result)
{
Application.Current.Dispatcher.Invoke(() =>
{
MainWindowStore.Instance().DisplayMessage("The filter cannot be added");
});
}
else
{
Application.Current.Dispatcher.Invoke(() =>
{
MainWindowStore.Instance().DisplayMessage("The filter has been added");
});
}
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying add the filter"));
}
});
}
private void PublishTransactionCall(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (_viewModel.SelectedSolidityContract == null)
{
MainWindowStore.Instance().DisplayError("Contract must be selected");
return;
}
if (_viewModel.SelectedFunctionDefinition == null)
{
MainWindowStore.Instance().DisplayError("Function must be selected");
return;
}
var callValue = _viewModel.SelectedFunctionDefinition.FunctionAgg.GetCallValue(_viewModel.SelectedFunctionDefinition.Parameters.Select(p => p.Value));
var rpcClient = new RpcClient(authenticatedWallet.Network);
var smartContractTransaction = new SmartContractTransaction
{
To = _viewModel.SelectedSolidityContract.Address.FromHexString(),
Data = callValue.FromHexString()
};
rpcClient.SendRawTransaction(smartContractTransaction).ContinueWith((t) =>
{
try
{
var txId = t.Result;
Application.Current.Dispatcher.Invoke(() =>
{
MainWindowStore.Instance().DisplayMessage(string.Format("A new transaction has been published : {0}", txId));
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to publish the transaction"));
}
});
}
private void GetLastLogs(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (_viewModel.SelectedFilter == null)
{
MainWindowStore.Instance().DisplayError("Please select a filter");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.GetFilterChanges(_viewModel.SelectedFilter.Id.FromHexString()).ContinueWith((t) =>
{
try
{
// _viewModel.SelectedSolidityContract.SolidityContractAgg
var addFilterResult = t.Result;
var displayedStr = new StringBuilder();
if (addFilterResult != null && addFilterResult.Any())
{
foreach (var addFilter in addFilterResult)
{
var res = _viewModel.SelectedSolidityContract.SolidityContractAgg.GetLogs(addFilter.Topics.First().GetData(), addFilter.Data);
displayedStr.AppendLine(string.Format("{0} : {1}", res.Function.GetFullName(), string.Join(",", res.Data.Select(r => System.Text.Encoding.UTF8.GetString(r.ToArray())))));
}
}
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayMessage(displayedStr.ToString()));
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying get the last changes"));
}
});
}
private void CallContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (_viewModel.SelectedSolidityContract == null)
{
MainWindowStore.Instance().DisplayError("Contract must be selected");
return;
}
if (_viewModel.SelectedFunctionDefinition == null)
{
MainWindowStore.Instance().DisplayError("Function must be selected");
return;
}
var callValue = _viewModel.SelectedFunctionDefinition.FunctionAgg.GetCallValue(_viewModel.SelectedFunctionDefinition.Parameters.Select(p => p.Value));
var smartContractTransactionParameter = new SmartContractTransactionParameter(_viewModel.SelectedSolidityContract.Address.FromHexString());
smartContractTransactionParameter.Data = callValue.FromHexString();
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.CallSmartContract(smartContractTransactionParameter).ContinueWith((t) =>
{
try
{
var smartContractResult = t.Result;
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayMessage(string.Format("Result of the operation : {0}", smartContractResult)));
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to call the contract"));
}
});
}
private void CompileContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (string.IsNullOrWhiteSpace(_viewModel.SmartContract))
{
MainWindowStore.Instance().DisplayError("The solidity contract must be filled in");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.CompileSolidity(_viewModel.SmartContract).ContinueWith((t) =>
{
try
{
var compilationResult = t.Result;
UpdateSmartContractDefinition(compilationResult);
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayMessage("The contract has been compiled"));
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to build the solidity contract"));
}
});
}
public Key CreateNewAddress()
{
var walletStore = WalletStore.Instance();
var authenticatedWallet = walletStore.GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
return(null);
}
var key = Key.Genererate();
var blockChainAdr = new BlockChainAddress(ScriptTypes.P2PKH, authenticatedWallet.Network, key);
authenticatedWallet.Addresses.Add(new WalletAggregateAddress
{
Hash = blockChainAdr.GetSerializedHash(),
Key = key,
Network = authenticatedWallet.Network
});
var password = walletStore.GetPassword();
_walletRepository.Update(authenticatedWallet, walletStore.GetPassword());
return(key);
}
private JObject ListUnspent(IEnumerable <string> parameters, JObject response, string id)
{
var transactions = MemoryPool.Instance().GetTransactions();
var blockChain = _blockChainStore.GetBlockChain();
var wallet = WalletStore.Instance().GetAuthenticatedWallet();
int confirmationScore = 1;
var maxConfirmations = 9999999;
IEnumerable <string> addrs = new List <string>();
if (parameters.Any())
{
if (int.TryParse(parameters.First().ToString(), out confirmationScore))
{
}
if (parameters.Count() >= 2 && int.TryParse(parameters.ElementAt(1), out maxConfirmations))
{
}
if (parameters.Count() >= 3)
{
var jArr = JArray.Parse(parameters.ElementAt(2));
if (jArr != null)
{
addrs = jArr.Select(j => j.ToString());
}
}
}
if (wallet == null)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_WALLET_NOT_FOUND, "No authenticated wallet"));
}
var res = new JArray();
if (addrs == null || !addrs.Any())
{
addrs = wallet.Addresses.Select(a => a.Hash);
}
var walletBlockChainAddrs = addrs.Select(a => new { bca = BlockChainAddress.Deserialize(a), hash = a });
if (maxConfirmations >= 0) // CONFIRMATION 0.
{
if (transactions != null && transactions.Any())
{
foreach (var unconfirmedTransaction in transactions)
{
if (unconfirmedTransaction.Transaction != null)
{
var lBcTx = unconfirmedTransaction.Transaction as BcBaseTransaction;
if (lBcTx == null)
{
continue;
}
foreach (var unconfirmedUTXO in lBcTx.TransactionOut.Where(t => t is TransactionOut).Select(t => t as TransactionOut))
{
var bcAdr = walletBlockChainAddrs.FirstOrDefault(wph => unconfirmedUTXO.Script.ContainsPublicKeyHash(wph.bca.PublicKeyHash));
if (bcAdr == null)
{
continue;
}
var record = new JObject();
record.Add("txid", unconfirmedTransaction.Transaction.GetTxId().ToHexString());
record.Add("vout", lBcTx.TransactionOut.IndexOf(unconfirmedUTXO));
record.Add("amount", unconfirmedUTXO.Value);
record.Add("address", bcAdr.hash);
record.Add("scriptPubKey", unconfirmedUTXO.Script.Serialize().ToHexString());
record.Add("confirmations", 0);
record.Add("spendable", true);
record.Add("solvable", true);
res.Add(record);
}
}
}
}
}
if (maxConfirmations >= 1) // CONFIRMATION 1.
{
var utxos = blockChain.GetUnspentTransactions();
foreach (var utxo in utxos)
{
var bcAdr = walletBlockChainAddrs.FirstOrDefault(wph => utxo.Script.ContainsPublicKeyHash(wph.bca.PublicKeyHash));
if (bcAdr == null)
{
continue;
}
var record = new JObject();
record.Add("txid", utxo.TxId.ToHexString());
record.Add("vout", utxo.Index);
record.Add("address", bcAdr.hash);
record.Add("scriptPubKey", utxo.Script.Serialize().ToHexString());
record.Add("amount", utxo.Value);
record.Add("confirmations", 1);
record.Add("spendable", true);
record.Add("solvable", true);
res.Add(record);
}
}
response["result"] = res;
return(response);
}
private void SendMoney(object sender, EventArgs e)
{
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
var receiverValue = _viewModel.SendValue;
var addr = _viewModel.SendAddress;
var selectedTransaction = _viewModel.SelectedTransaction;
if (selectedTransaction == null)
{
MainWindowStore.Instance().DisplayError("A transaction must be selected");
return;
}
if (receiverValue > selectedTransaction.Amount)
{
return;
}
var txFee = _transactionHelper.GetMinFee();
var senderValue = selectedTransaction.Amount - receiverValue - txFee;
var walletAddr = authenticatedWallet.Addresses.FirstOrDefault(a => a.Hash == selectedTransaction.Hash);
if (walletAddr == null)
{
MainWindowStore.Instance().DisplayError("The selected tranasction is not linked to your wallet");
return;
}
BlockChainAddress bcAddr = null;
try
{
bcAddr = BlockChainAddress.Deserialize(addr);
}
catch (Exception)
{
MainWindowStore.Instance().DisplayError("The address is not correct");
}
if (bcAddr == null)
{
MainWindowStore.Instance().DisplayError("The address is not correct");
return;
}
var newKey = _walletHelper.CreateNewAddress();
var kh = new BigInteger(newKey.GetPublicKeyHashed());
var script = _scriptBuilder.New()
.AddToStack(walletAddr.Key.GetSignature())
.AddToStack(walletAddr.Key.GetPublicKey())
.Build();
var pp = walletAddr.Key.GetPublicKeyHashed();
var senderSript = _scriptBuilder.New() // SEND MONEY TO MY WALLET.
.AddOperation(OpCodes.OP_DUP)
.AddOperation(OpCodes.OP_HASH160)
.AddToStack(newKey.GetPublicKeyHashed())
.AddOperation(OpCodes.OP_EQUALVERIFY)
.AddOperation(OpCodes.OP_CHECKSIG)
.Build();
var receiverScript = _scriptBuilder.New() // SEND MONEY TO THE SELLER.
.AddOperation(OpCodes.OP_DUP)
.AddOperation(OpCodes.OP_HASH160)
.AddToStack(bcAddr.PublicKeyHash)
.AddOperation(OpCodes.OP_EQUALVERIFY)
.AddOperation(OpCodes.OP_CHECKSIG)
.Build();
var txBuilder = _transactionBuilder.NewNoneCoinbaseTransaction()
.Spend(selectedTransaction.TxId.FromHexString(), (uint)selectedTransaction.Vout, script.Serialize())
.AddOutput((long)receiverValue, receiverScript);
if (senderValue > 0)
{
txBuilder.AddOutput((long)senderValue, senderSript);
}
var tx = txBuilder.Build();
var s = tx.Serialize().Count();
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.SendRawTransaction(tx).ContinueWith((r) =>
{
try
{
var res = r.Result;
}
catch (AggregateException ex)
{
var exx = ex.InnerExceptions;
}
});
}
private void PersistSmartContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (string.IsNullOrWhiteSpace(_viewModel.TransactionId))
{
MainWindowStore.Instance().DisplayError("The transaction address must be filled in");
return;
}
if (_publishedSolidityContract == null)
{
MainWindowStore.Instance().DisplayError("The smart contract must be published");
return;
}
IEnumerable <byte> txId = null;
try
{
txId = _viewModel.TransactionId.FromHexString();
}
catch (Exception)
{
MainWindowStore.Instance().DisplayError("The transaction address is not a valid hex");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
rpcClient.GetTransactionReceipt(txId).ContinueWith((r) =>
{
try
{
_publishedSolidityContract.Address = r.Result.ContractAddress;
_solidityContractsRepository.Insert(_publishedSolidityContract).ContinueWith((t) =>
{
try
{
if (t.Result)
{
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.NewSmartContractAddress = r.Result.ContractAddress;
_publishedSolidityContract = null;
MainWindowStore.Instance().DisplayMessage("The transaction has been inserted");
});
}
else
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to insert the smart contract"));
}
}
catch
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to insert the smart contract"));
}
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to insert the smart contract"));
}
});
}
private void PublishContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (string.IsNullOrWhiteSpace(_viewModel.SmartContract))
{
MainWindowStore.Instance().DisplayError("The solidity contract must be filled in");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
_publishedSolidityContract = null;
rpcClient.CompileSolidity(_viewModel.SmartContract).ContinueWith((t) =>
{
try
{
var compilationResult = t.Result;
if (compilationResult.Infos == null || !compilationResult.Infos.Any())
{
return;
}
UpdateSmartContractDefinition(compilationResult);
var newKey = _walletHelper.CreateNewAddress();
var fromAddr = newKey.GetPublicKeyHashed();
var smartContractTransaction = new SmartContractTransaction
{
From = fromAddr,
Data = compilationResult.Infos.First().Code.FromHexString(),
Nonce = NonceHelper.GetNonceInt32()
};
rpcClient.SendRawTransaction(smartContractTransaction).ContinueWith((c) =>
{
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.TransactionId = c.Result;
});
_publishedSolidityContract = new SolidityContractAggregate
{
Abi = compilationResult.Infos.First().AbiDefinition.ToString(),
Code = compilationResult.Infos.First().Code
};
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to build the solidity contract"));
}
});
}
private void RefreshBlocks()
{
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
var startIndex = 0;
var lastIndex = WalletPageStore.Instance().NbBlocks;
var waitBlockHashes = new List <Task <IEnumerable <byte> > >();
for (var i = startIndex; i < lastIndex; i++)
{
waitBlockHashes.Add(rpcClient.GetBlockHash(i));
}
Task.WhenAll(waitBlockHashes.ToArray()).ContinueWith((r) =>
{
var waitAllBlocks = new List <Task <Block> >();
try
{
var lstBHash = r.Result.ToList();
foreach (var bHash in lstBHash)
{
if (bHash == null)
{
continue;
}
waitAllBlocks.Add(rpcClient.GetBlock(bHash));
}
}
catch (AggregateException) { }
Task.WhenAll(waitAllBlocks.ToArray()).ContinueWith((b) =>
{
try
{
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.Blocks.Clear();
});
var blocks = b.Result;
foreach (var block in blocks)
{
if (block == null)
{
continue;
}
var blockHash = block.GetHashHeader().ToHexString();
var previousHash = block.BlockHeader.PreviousBlockHeader.ToHexString();
var nbTransactions = block.Transactions.Count();
var fees = block.GetTotalFees();
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.Blocks.Add(new BlockViewModel
{
Fees = fees,
Hash = blockHash,
PreviousHash = previousHash
});
});
}
}
catch (AggregateException) { }
});
});
}
