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) { } }); }); }