//TransactionOutput、TransactionInput、CoinbaseTransaction、TransferTransactionのテスト public static void Test10() { Ecdsa256KeyPair keypair1 = new Ecdsa256KeyPair(true); Ecdsa256KeyPair keypair2 = new Ecdsa256KeyPair(true); Ecdsa256KeyPair keypair3 = new Ecdsa256KeyPair(true); Sha256Ripemd160Hash address1 = new Sha256Ripemd160Hash(keypair1.pubKey.pubKey); CurrencyUnit amount1 = new Creacoin(50.0m); Sha256Ripemd160Hash address2 = new Sha256Ripemd160Hash(keypair2.pubKey.pubKey); CurrencyUnit amount2 = new Creacoin(25.0m); Sha256Ripemd160Hash address3 = new Sha256Ripemd160Hash(keypair3.pubKey.pubKey); CurrencyUnit amount3 = new Yumina(0.01m); TransactionOutput txOut1 = new TransactionOutput(); txOut1.LoadVersion0(address1, amount1); TransactionOutput txOut2 = new TransactionOutput(); txOut2.LoadVersion0(address2, amount2); TransactionOutput txOut3 = new TransactionOutput(); txOut3.LoadVersion0(address3, amount3); if (txOut1.Address != address1) throw new Exception("test10_1"); if (txOut1.Amount != amount1) throw new Exception("test10_2"); byte[] txOutBytes = txOut1.ToBinary(); if (txOutBytes.Length != 29) throw new Exception("test10_3"); TransactionOutput txOutRestore = SHAREDDATA.FromBinary<TransactionOutput>(txOutBytes, 0); if (!txOut1.Address.Equals(txOutRestore.Address)) throw new Exception("test10_4"); if (txOut1.Amount.rawAmount != txOutRestore.Amount.rawAmount) throw new Exception("test10_5"); TransactionInput txIn1 = new TransactionInput(); txIn1.LoadVersion0(0, 0, 0, keypair1.pubKey); TransactionInput txIn2 = new TransactionInput(); txIn2.LoadVersion0(1, 0, 0, keypair2.pubKey); TransactionInput txIn3 = new TransactionInput(); txIn3.LoadVersion0(2, 0, 0, keypair3.pubKey); if (txIn1.PrevTxBlockIndex != 0) throw new Exception("test10_6"); if (txIn1.PrevTxIndex != 0) throw new Exception("test10_7"); if (txIn1.PrevTxOutputIndex != 0) throw new Exception("test10_8"); if (txIn1.SenderPubKey != keypair1.pubKey) throw new Exception("test10_9"); TransactionOutput[] txOuts = new TransactionOutput[] { txOut1, txOut2, txOut3 }; CoinbaseTransaction cTx = new CoinbaseTransaction(); cTx.LoadVersion0(txOuts); if (cTx.TxOutputs != txOuts) throw new Exception("test10_10"); if (cTx.TxInputs.Length != 0) throw new Exception("test10_11"); byte[] cTxBytes = cTx.ToBinary(); if (cTxBytes.Length != 97) throw new Exception("test10_12"); CoinbaseTransaction cTxRestore = SHAREDDATA.FromBinary<CoinbaseTransaction>(cTxBytes); if (!cTx.Id.Equals(cTxRestore.Id)) throw new Exception("test10_13"); if (cTx.Verify()) throw new Exception("test10_14"); if (cTx.VerifyNotExistDustTxOutput()) throw new Exception("test10_15"); if (!cTx.VerifyNumberOfTxInputs()) throw new Exception("test10_16"); if (!cTx.VerifyNumberOfTxOutputs()) throw new Exception("test10_17"); TransactionOutput[] txOuts2 = new TransactionOutput[11]; for (int i = 0; i < txOuts2.Length; i++) txOuts2[i] = txOut1; CoinbaseTransaction cTx2 = new CoinbaseTransaction(); cTx2.LoadVersion0(txOuts2); if (cTx2.Verify()) throw new Exception("test10_18"); if (!cTx2.VerifyNotExistDustTxOutput()) throw new Exception("test10_19"); if (!cTx2.VerifyNumberOfTxInputs()) throw new Exception("test10_20"); if (cTx2.VerifyNumberOfTxOutputs()) throw new Exception("test10_21"); TransactionOutput[] txOuts3 = new TransactionOutput[] { txOut1, txOut2 }; CoinbaseTransaction cTx3 = new CoinbaseTransaction(); cTx3.LoadVersion0(txOuts3); if (!cTx3.Verify()) throw new Exception("test10_22"); if (!cTx3.VerifyNotExistDustTxOutput()) throw new Exception("test10_23"); if (!cTx3.VerifyNumberOfTxInputs()) throw new Exception("test10_24"); if (!cTx3.VerifyNumberOfTxOutputs()) throw new Exception("test10_25"); TransactionInput[] txIns = new TransactionInput[] { txIn1, txIn2, txIn3 }; TransferTransaction tTx1 = new TransferTransaction(); tTx1.LoadVersion0(txIns, txOuts); tTx1.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (tTx1.TxInputs != txIns) throw new Exception("test10_26"); if (tTx1.TxOutputs != txOuts) throw new Exception("test10_27"); byte[] txInBytes = txIn1.ToBinary(); if (txInBytes.Length != 153) throw new Exception("test10_28"); TransactionInput txInRestore = SHAREDDATA.FromBinary<TransactionInput>(txInBytes, 0); if (txIn1.PrevTxBlockIndex != txInRestore.PrevTxBlockIndex) throw new Exception("test10_29"); if (txIn1.PrevTxIndex != txInRestore.PrevTxIndex) throw new Exception("test10_30"); if (txIn1.PrevTxOutputIndex != txInRestore.PrevTxOutputIndex) throw new Exception("test10_31"); if (!txIn1.SenderPubKey.pubKey.BytesEquals(txInRestore.SenderPubKey.pubKey)) throw new Exception("test10_32"); if (!txIn1.SenderSignature.signature.BytesEquals(txInRestore.SenderSignature.signature)) throw new Exception("test10_33"); byte[] tTxBytes = tTx1.ToBinary(); if (tTxBytes.Length != 557) throw new Exception("test10_34"); TransferTransaction tTxRestore = SHAREDDATA.FromBinary<TransferTransaction>(tTxBytes); if (!tTx1.Id.Equals(tTxRestore.Id)) throw new Exception("test10_35"); if (tTx1.Verify(txOuts)) throw new Exception("test10_36"); if (tTx1.VerifyNotExistDustTxOutput()) throw new Exception("test10_37"); if (!tTx1.VerifyNumberOfTxInputs()) throw new Exception("test10_38"); if (!tTx1.VerifyNumberOfTxOutputs()) throw new Exception("test10_39"); if (!tTx1.VerifySignature(txOuts)) throw new Exception("test10_40"); if (!tTx1.VerifyPubKey(txOuts)) throw new Exception("test10_41"); if (!tTx1.VerifyAmount(txOuts)) throw new Exception("test10_42"); if (tTx1.GetFee(txOuts).rawAmount != 0) throw new Exception("test10_43"); TransactionOutput[] txOuts4 = new TransactionOutput[] { txOut2, txOut1, txOut3 }; if (tTx1.Verify(txOuts4)) throw new Exception("test10_44"); if (tTx1.VerifySignature(txOuts4)) throw new Exception("test10_45"); if (tTx1.VerifyPubKey(txOuts4)) throw new Exception("test10_46"); byte temp2 = tTx1.TxInputs[0].SenderSignature.signature[0]; tTx1.TxInputs[0].SenderSignature.signature[0] = 0; if (tTx1.Verify(txOuts)) throw new Exception("test10_47"); if (tTx1.VerifySignature(txOuts)) throw new Exception("test10_48"); if (!tTx1.VerifyPubKey(txOuts)) throw new Exception("test10_49"); tTx1.TxInputs[0].SenderSignature.signature[0] = temp2; TransferTransaction tTx2 = new TransferTransaction(); tTx2.LoadVersion0(txIns, txOuts); tTx2.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair2.privKey, keypair1.privKey, keypair3.privKey }); if (tTx2.Verify(txOuts)) throw new Exception("test10_50"); if (tTx2.VerifySignature(txOuts)) throw new Exception("test10_51"); if (!tTx2.VerifyPubKey(txOuts)) throw new Exception("test10_52"); TransferTransaction tTx3 = new TransferTransaction(); tTx3.LoadVersion0(txIns, txOuts); tTx3.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); byte temp = tTx3.TxInputs[0].SenderPubKey.pubKey[0]; tTx3.TxInputs[0].SenderPubKey.pubKey[0] = 0; if (tTx3.Verify(txOuts)) throw new Exception("test10_50"); if (tTx3.VerifySignature(txOuts)) throw new Exception("test10_51"); if (tTx3.VerifyPubKey(txOuts)) throw new Exception("test10_52"); tTx3.TxInputs[0].SenderPubKey.pubKey[0] = temp; TransferTransaction tTx4 = new TransferTransaction(); tTx4.LoadVersion0(txIns, txOuts2); tTx4.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (tTx4.Verify(txOuts)) throw new Exception("test10_53"); if (!tTx4.VerifyNotExistDustTxOutput()) throw new Exception("test10_54"); if (!tTx4.VerifyNumberOfTxInputs()) throw new Exception("test10_55"); if (tTx4.VerifyNumberOfTxOutputs()) throw new Exception("test10_56"); if (!tTx4.VerifySignature(txOuts)) throw new Exception("test10_57"); if (!tTx4.VerifyPubKey(txOuts)) throw new Exception("test10_58"); if (tTx4.VerifyAmount(txOuts)) throw new Exception("test10_59"); if (tTx4.GetFee(txOuts).rawAmount != -47499990000) throw new Exception("test10_60"); TransferTransaction tTx5 = new TransferTransaction(); tTx5.LoadVersion0(txIns, txOuts3); tTx5.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (!tTx5.Verify(txOuts)) throw new Exception("test10_61"); if (!tTx5.VerifyNotExistDustTxOutput()) throw new Exception("test10_62"); if (!tTx5.VerifyNumberOfTxInputs()) throw new Exception("test10_63"); if (!tTx5.VerifyNumberOfTxOutputs()) throw new Exception("test10_64"); if (!tTx5.VerifySignature(txOuts)) throw new Exception("test10_65"); if (!tTx5.VerifyPubKey(txOuts)) throw new Exception("test10_66"); if (!tTx5.VerifyAmount(txOuts)) throw new Exception("test10_67"); if (tTx5.GetFee(txOuts).rawAmount != 10000) throw new Exception("test10_68"); TransactionInput[] txIns2 = new TransactionInput[101]; for (int i = 0; i < txIns2.Length; i++) txIns2[i] = txIn1; TransactionOutput[] txOuts5 = new TransactionOutput[txIns2.Length]; for (int i = 0; i < txOuts5.Length; i++) txOuts5[i] = txOut1; Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[txIns2.Length]; for (int i = 0; i < privKeys.Length; i++) privKeys[i] = keypair1.privKey; TransferTransaction tTx6 = new TransferTransaction(); tTx6.LoadVersion0(txIns2, txOuts3); tTx6.Sign(txOuts5, privKeys); if (tTx6.Verify(txOuts5)) throw new Exception("test10_61"); if (!tTx6.VerifyNotExistDustTxOutput()) throw new Exception("test10_62"); if (tTx6.VerifyNumberOfTxInputs()) throw new Exception("test10_63"); if (!tTx6.VerifyNumberOfTxOutputs()) throw new Exception("test10_64"); if (!tTx6.VerifySignature(txOuts5)) throw new Exception("test10_65"); if (!tTx6.VerifyPubKey(txOuts5)) throw new Exception("test10_66"); if (!tTx6.VerifyAmount(txOuts5)) throw new Exception("test10_67"); if (tTx6.GetFee(txOuts5).rawAmount != 497500000000) throw new Exception("test10_68"); byte[] cTxBytes2 = SHAREDDATA.ToBinary<Transaction>(cTx); if (cTxBytes2.Length != 117) throw new Exception("test10_69"); CoinbaseTransaction cTxRestore2 = SHAREDDATA.FromBinary<Transaction>(cTxBytes2) as CoinbaseTransaction; if (!cTx.Id.Equals(cTxRestore2.Id)) throw new Exception("test10_70"); byte[] tTxBytes2 = SHAREDDATA.ToBinary<Transaction>(tTx6); if (tTxBytes2.Length != 15445) throw new Exception("test10_71"); TransferTransaction tTxRestore2 = SHAREDDATA.FromBinary<Transaction>(tTxBytes2) as TransferTransaction; if (!tTx6.Id.Equals(tTxRestore2.Id)) throw new Exception("test10_72"); Sha256Sha256Hash ctxid = new Sha256Sha256Hash(cTxBytes); if (!ctxid.Equals(cTx.Id)) throw new Exception("test10_73"); Sha256Sha256Hash ttxid = new Sha256Sha256Hash(tTx6.ToBinary()); if (!ttxid.Equals(tTx6.Id)) throw new Exception("test10_74"); Console.WriteLine("test10_succeeded"); }
public void StartSystem() { if (isSystemStarted) { throw new InvalidOperationException("core_started"); } ahdb = new AccountHoldersDatabase(databaseBasepath); thdb = new TransactionHistoriesDatabase(databaseBasepath); bcadb = new BlockchainAccessDB(databaseBasepath); bmdb = new BlockManagerDB(databaseBasepath); bdb = new BlockDB(databaseBasepath); bfpdb = new BlockFilePointersDB(databaseBasepath); ufadb = new UtxoFileAccessDB(databaseBasepath); ufpdb = new UtxoFilePointersDB(databaseBasepath); ufptempdb = new UtxoFilePointersTempDB(databaseBasepath); utxodb = new UtxoDB(databaseBasepath); accountHolders = new AccountHolders(); accountHoldersFactory = new AccountHoldersFactory(); byte[] ahDataBytes = ahdb.GetData(); if (ahDataBytes.Length != 0) { accountHolders.FromBinary(ahDataBytes); } else { accountHolders.LoadVersion0(); } transactionHistories = thdb.GetData().Pipe((data) => data.Length == 0 ? new TransactionHistories() : SHAREDDATA.FromBinary <TransactionHistories>(data)); transactionHistories.UnconfirmedTransactionAdded += (sender, e) => { foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { foreach (var prevTxOut in e.senders) { if (account.Address.Equals(prevTxOut.Address)) { account.accountStatus.unconfirmedAmount = new CurrencyUnit(account.accountStatus.unconfirmedAmount.rawAmount + prevTxOut.Amount.rawAmount); } } } } }; transactionHistories.UnconfirmedTransactionRemoved += (sender, e) => { foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { foreach (var prevTxOut in e.receivers) { if (account.Address.Equals(prevTxOut.Address)) { account.accountStatus.unconfirmedAmount = new CurrencyUnit(account.accountStatus.unconfirmedAmount.rawAmount - prevTxOut.Amount.rawAmount); } } } } }; usableBalanceCache = new CachedData <CurrencyUnit>(() => { long rawAmount = 0; foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { rawAmount += account.accountStatus.usableAmount.rawAmount; } } return(new CurrencyUnit(rawAmount)); }); unusableBalanceCache = new CachedData <CurrencyUnit>(() => { long rawAmount = 0; foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { rawAmount += account.accountStatus.unusableAmount.rawAmount; } } return(new CurrencyUnit(rawAmount)); }); unconfirmedBalanceCache = new CachedData <CurrencyUnit>(() => { long rawAmount = 0; foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { rawAmount += account.accountStatus.unconfirmedAmount.rawAmount; } } return(new CurrencyUnit(rawAmount)); }); usableBalanceWithUnconfirmedCache = new CachedData <CurrencyUnit>(() => new CurrencyUnit(usableBalanceCache.Data.rawAmount - unconfirmedBalanceCache.Data.rawAmount)); unusableBalanceWithUnconformedCache = new CachedData <CurrencyUnit>(() => new CurrencyUnit(unusableBalanceCache.Data.rawAmount + unconfirmedBalanceCache.Data.rawAmount)); blockChain = new BlockChain(bcadb, bmdb, bdb, bfpdb, ufadb, ufpdb, ufptempdb, utxodb); blockChain.LoadTransactionHistories(transactionHistories); //<未改良>暫定? if (blockChain.headBlockIndex == -1) { blockChain.UpdateChain(new GenesisBlock()); this.RaiseNotification("genesis_block_generated", 5); } Dictionary <Account, EventHandler <Tuple <CurrencyUnit, CurrencyUnit> > > changeAmountDict = new Dictionary <Account, EventHandler <Tuple <CurrencyUnit, CurrencyUnit> > >(); Action <bool> _UpdateBalance = (isOnlyUnconfirmed) => { if (!isOnlyUnconfirmed) { usableBalanceCache.IsModified = true; unusableBalanceCache.IsModified = true; } unconfirmedBalanceCache.IsModified = true; usableBalanceWithUnconfirmedCache.IsModified = true; unusableBalanceWithUnconformedCache.IsModified = true; BalanceUpdated(this, EventArgs.Empty); }; Action <Account, bool> _AddAddressEvent = (account, isUpdatebalance) => { EventHandler <Tuple <CurrencyUnit, CurrencyUnit> > eh = (sender, e) => { account.accountStatus.usableAmount = e.Item1; account.accountStatus.unusableAmount = e.Item2; }; changeAmountDict.Add(account, eh); AddressEvent addressEvent = new AddressEvent(account.Address.Hash); addressEvent.BalanceUpdated += eh; blockChain.AddAddressEvent(addressEvent); long rawAmount = 0; foreach (var unconfirmedTh in transactionHistories.unconfirmedTransactionHistories.ToArray()) { foreach (var prevTxOut in unconfirmedTh.senders) { if (prevTxOut.Address.Equals(account.Address)) { rawAmount += prevTxOut.Amount.rawAmount; } } } account.accountStatus.unconfirmedAmount = new CurrencyUnit(rawAmount); if (isUpdatebalance) { _UpdateBalance(false); } }; EventHandler <Account> _AccountAdded = (sender, e) => { utxodb.Open(); _AddAddressEvent(e, true); utxodb.Close(); }; EventHandler <Account> _AccountRemoved = (sender, e) => { EventHandler <Tuple <CurrencyUnit, CurrencyUnit> > eh = changeAmountDict[e]; changeAmountDict.Remove(e); AddressEvent addressEvent = blockChain.RemoveAddressEvent(e.Address.Hash); addressEvent.BalanceUpdated -= eh; _UpdateBalance(false); }; utxodb.Open(); foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { _AddAddressEvent(account, false); } accountHolder.AccountAdded += _AccountAdded; accountHolder.AccountRemoved += _AccountRemoved; } utxodb.Close(); accountHolders.AccountHolderAdded += (sender, e) => { e.AccountAdded += _AccountAdded; e.AccountRemoved += _AccountRemoved; }; accountHolders.AccountHolderRemoved += (semder, e) => { e.AccountAdded -= _AccountAdded; e.AccountRemoved -= _AccountRemoved; }; blockChain.BalanceUpdated += (sender, e) => _UpdateBalance(false); _UpdateBalance(false); unconfirmedTtxs = new Dictionary <TransferTransaction, TransactionOutput[]>(); mining = new Mining(); mining.FoundNonce += (sender, e) => creaNodeTest.DiffuseNewBlock(e); blockChain.Updated += (sender, e) => { foreach (var block in e) { foreach (var tx in block.Transactions) { foreach (var txIn in tx.TxInputs) { TransferTransaction contradiction = null; foreach (var unconfirmedTx in unconfirmedTtxs) { foreach (var unconfirmedTxIn in unconfirmedTx.Key.TxInputs) { if (txIn.PrevTxBlockIndex == unconfirmedTxIn.PrevTxBlockIndex && txIn.PrevTxIndex == unconfirmedTxIn.PrevTxIndex && txIn.PrevTxOutputIndex == unconfirmedTxIn.PrevTxOutputIndex) { contradiction = unconfirmedTx.Key; break; } } if (contradiction != null) { break; } } if (contradiction != null) { unconfirmedTtxs.Remove(contradiction); } } } } Mine(); }; Mine(); //creaNodeTest = new CreaNode(ps.NodePort, creaVersion, appnameWithVersion, new FirstNodeInfosDatabase(p2pDirectory)); creaNodeTest = new CreaNodeTest(blockChain, ps.NodePort, creaVersion, appnameWithVersion); creaNodeTest.ConnectionKeeped += (sender, e) => creaNodeTest.SyncronizeBlockchain(); creaNodeTest.ReceivedNewTransaction += (sender, e) => { TransferTransaction ttx = e as TransferTransaction; if (ttx == null) { return; } TransactionOutput[] prevTxOuts = new TransactionOutput[ttx.TxInputs.Length]; for (int i = 0; i < prevTxOuts.Length; i++) { prevTxOuts[i] = blockChain.GetMainBlock(ttx.TxInputs[i].PrevTxBlockIndex).Transactions[ttx.TxInputs[i].PrevTxIndex].TxOutputs[ttx.TxInputs[i].PrevTxOutputIndex]; } if (!ttx.Verify(prevTxOuts)) { return; } List <TransactionOutput> senders = new List <TransactionOutput>(); List <TransactionOutput> receivers = new List <TransactionOutput>(); long sentAmount = 0; long receivedAmount = 0; for (int i = 0; i < ttx.txInputs.Length; i++) { foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { if (prevTxOuts[i].Address.Equals(account.Address.Hash)) { sentAmount += prevTxOuts[i].Amount.rawAmount; senders.Add(prevTxOuts[i]); } } } } for (int i = 0; i < ttx.TxOutputs.Length; i++) { foreach (var accountHolder in accountHolders.AllAccountHolders) { foreach (var account in accountHolder.Accounts) { if (ttx.TxOutputs[i].Address.Equals(account.Address.Hash)) { receivedAmount += ttx.TxOutputs[i].Amount.rawAmount; receivers.Add(ttx.TxOutputs[i]); } } } } if (senders.Count > 0 || receivers.Count > 0) { TransactionHistoryType type = TransactionHistoryType.transfered; if (receivers.Count < ttx.TxOutputs.Length) { type = TransactionHistoryType.sent; } else if (senders.Count < ttx.TxInputs.Length) { type = TransactionHistoryType.received; } transactionHistories.AddTransactionHistory(new TransactionHistory(true, false, type, DateTime.MinValue, 0, ttx.Id, senders.ToArray(), receivers.ToArray(), ttx, prevTxOuts, new CurrencyUnit(sentAmount), new CurrencyUnit(receivedAmount - sentAmount))); } utxodb.Open(); for (int i = 0; i < ttx.TxInputs.Length; i++) { if (blockChain.FindUtxo(prevTxOuts[i].Address, ttx.TxInputs[i].PrevTxBlockIndex, ttx.TxInputs[i].PrevTxIndex, ttx.TxInputs[i].PrevTxOutputIndex) == null) { return; } } utxodb.Close(); foreach (var txIn in ttx.TxInputs) { foreach (var unconfirmedTtx in unconfirmedTtxs) { foreach (var unconfirmedTxIn in unconfirmedTtx.Key.TxInputs) { if (txIn.PrevTxBlockIndex == unconfirmedTxIn.PrevTxBlockIndex && txIn.PrevTxIndex == unconfirmedTxIn.PrevTxIndex && txIn.PrevTxOutputIndex == unconfirmedTxIn.PrevTxOutputIndex) { return; } } } } unconfirmedTtxs.Add(ttx, prevTxOuts); Mine(); }; creaNodeTest.ReceivedNewBlock += (sender, e) => blockChain.UpdateChain(e).Pipe((ret) => this.RaiseResult("blockchain_update", 5, ret.ToString())); //creaNodeTest.Start(); isSystemStarted = true; }