public void onDeleteWallet(object sender, EventArgs e) { if (IxianHandler.getWalletStorage().deleteWallet()) { // Also delete the account onDeleteAccount(sender, e); // Stop network activity Node.stop(); Application.Current.Properties.Remove("onboardingComplete"); Application.Current.Properties.Remove("lockenabled"); Application.Current.Properties.Remove("waletpass"); Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF SpixiLocalization.addCustomString("OnboardingComplete", "false"); Node.localStorage.deleteTransactionCacheFile(); TransactionCache.clearAllTransactions(); Node.tiv.clearCache(); // Show the launch page Navigation.PushAsync(new LaunchPage(), Config.defaultXamarinAnimations); // Remove the settings page Navigation.RemovePage(this); // Todo: also remove the parent page without causing memory leaks } else { displaySpixiAlert(SpixiLocalization._SL("settings-deletew-error-title"), SpixiLocalization._SL("settings-deletew-error-text"), SpixiLocalization._SL("global-dialog-ok")); } }
// returns statistics about the unspent transactions private JsonResponse onGetTxOutsetInfo() { Block block = IxianHandler.getLastBlock(); Transaction[] unapplied_txs = TransactionPool.getUnappliedTransactions(); long txouts = 0; IxiNumber total_amount = new IxiNumber(0); foreach (Transaction tx in unapplied_txs) { txouts += tx.toList.Count(); total_amount += tx.amount + tx.fee; } Dictionary <string, Object> result_array = new Dictionary <string, Object> { { "height", block.blockNum }, // Block height { "bestblock", Crypto.hashToString(block.blockChecksum) }, // Block checksum { "transactions", unapplied_txs.LongCount() }, // Number of transactions { "txouts", txouts }, // Number of transaction outputs { "total_amount", total_amount.ToString() } // Total amount }; return(new JsonResponse { result = result_array, error = null }); }
public static void acceptFile(Friend friend, string uid) { using (MemoryStream m = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(m)) { writer.Write(uid); } FileTransfer transfer = getIncomingTransfer(uid); if (transfer == null) { return; } Logging.info("Accepting file {0}", transfer.fileName); transfer.lastTimeStamp = Clock.getTimestamp(); transfer.filePath = Path.Combine(downloadsPath, transfer.fileName + "." + uid + ".ixipart"); transfer.fileStream = File.Create(transfer.filePath); transfer.fileStream.SetLength((long)transfer.fileSize); SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.acceptFile, m.ToArray()); StreamMessage message = new StreamMessage(); message.type = StreamMessageCode.data; message.recipient = friend.walletAddress; message.sender = IxianHandler.getWalletStorage().getPrimaryAddress(); message.data = spixi_message.getBytes(); StreamProcessor.sendMessage(friend, message); } }
private static void queueLoop(List <QueueMessageRecv> queue) { // Prepare an special message object to use while receiving and parsing, without locking up the queue messages QueueMessageRecv active_message = new QueueMessageRecv(); while (!shouldStop) { TLC.Report(); bool message_found = false; lock (queue) { if (queue.Count > 0) { // Pick the oldest message active_message = queue[0]; message_found = true; // Remove it from the queue queue.RemoveAt(0); } } if (message_found) { Logging.trace("Received {0} ({1}B) - {2}...", active_message.code, active_message.data.Length, Crypto.hashToString(active_message.data.Take(60).ToArray())); // Active message set, attempt to parse it IxianHandler.parseProtocolMessage(active_message.code, active_message.data, active_message.endpoint); } else { // Sleep for 10ms to prevent cpu waste Thread.Sleep(10); } } Logging.info("Network queue thread stopped."); }
/// <summary> /// Subscribes client to transactionFrom, transactionTo and balance /// </summary> /// <remarks> /// This function is used to ensure that the remote endpoing has listed the correct IP and port information for their `PresenceList` entry. /// </remarks> /// <param name="endpoint">Target endpoint to verify for connectivity.</param> public static void subscribeToEvents(RemoteEndpoint endpoint) { if (endpoint.presenceAddress.type != 'M') { return; } // TODO TODO TODO events can be optimized as there is no real need to subscribe them to every connected node // Subscribe to transaction events, for own addresses var my_addresses = IxianHandler.getWalletStorage().getMyAddresses(); Cuckoo filter = new Cuckoo(my_addresses.Count()); foreach (var addr in my_addresses) { filter.Add(addr.address); } byte[] filter_data = filter.getFilterBytes(); byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionFrom, filter_data); endpoint.sendData(ProtocolMessageCode.attachEvent, event_data); event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionTo, filter_data); endpoint.sendData(ProtocolMessageCode.attachEvent, event_data); event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.balance, filter_data); endpoint.sendData(ProtocolMessageCode.attachEvent, event_data); }
static public void sendTransaction(string address, IxiNumber amount) { Node.getBalance(); if (Node.balance.balance < amount) { Console.WriteLine("Insufficient funds.\n"); return; } SortedDictionary <byte[], IxiNumber> to_list = new SortedDictionary <byte[], IxiNumber>(new ByteArrayComparer()); IxiNumber fee = ConsensusConfig.transactionPrice; byte[] from = IxianHandler.getWalletStorage().getPrimaryAddress(); byte[] pubKey = IxianHandler.getWalletStorage().getPrimaryPublicKey(); to_list.AddOrReplace(Base58Check.Base58CheckEncoding.DecodePlain(address), amount); Transaction transaction = new Transaction((int)Transaction.Type.Normal, fee, to_list, from, null, pubKey, IxianHandler.getHighestKnownNetworkBlockHeight()); if (IxianHandler.addTransaction(transaction, true)) { Console.WriteLine("Sending transaction, txid: {0}\n", Transaction.txIdV8ToLegacy(transaction.id)); } else { Console.WriteLine("Could not send transaction\n"); } }
private void onDecline() { if (requestMsg != null) { // send decline if (!requestMsg.message.StartsWith(":")) { string msg_id = Crypto.hashToString(requestMsg.id); SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.requestFundsResponse, Encoding.UTF8.GetBytes(msg_id)); requestMsg.message = "::" + requestMsg.message; StreamMessage message = new StreamMessage(); message.type = StreamMessageCode.info; message.recipient = friend.walletAddress; message.sender = IxianHandler.getWalletStorage().getPrimaryAddress(); message.data = spixi_message.getBytes(); StreamProcessor.sendMessage(friend, message); Node.localStorage.requestWriteMessages(friend.walletAddress, 0); if (friend.chat_page != null) { friend.chat_page.updateRequestFundsStatus(requestMsg.id, null, SpixiLocalization._SL("chat-payment-status-declined")); } } } Navigation.PopAsync(Config.defaultXamarinAnimations); }
public void scanForLostAddresses() { bool new_address_found = false; foreach (var key in myKeys) { Address primary_address = new Address(key.Value.addressBytes); byte[] last_nonce = key.Value.lastNonceBytes; for (int i = 0; i < 100; i++) { Address new_address = generateNewAddress(primary_address, last_nonce, false, false); if (IxianHandler.getWalletBalance(new_address.address) > 0) { new_address_found = true; for (int j = 0; j <= i; j++) { generateNewAddress(primary_address, null, true, false); } i = 0; } last_nonce = new_address.nonce; } } if (new_address_found) { writeWallet(walletPassword); } }
public static void sendNickname(byte[] recipient, byte[] contact_address) { if (contact_address != null && contact_address.Length > 1) { if (!Node.users.hasUser(contact_address)) { return; } byte[] nickData = Node.users.getUser(contact_address).nickData; if (nickData != null) { sendMessage(recipient, new StreamMessage(nickData)); } return; } SpixiMessage reply_spixi_message = new SpixiMessage(SpixiMessageCode.nick, Encoding.UTF8.GetBytes(Config.botName)); byte[] sender = IxianHandler.getWalletStorage().getPrimaryAddress(); // Send the nickname message to friend StreamMessage reply_message = new StreamMessage(); reply_message.type = StreamMessageCode.info; reply_message.recipient = recipient; reply_message.sender = sender; reply_message.data = reply_spixi_message.getBytes(); reply_message.encryptionType = StreamMessageEncryptionCode.none; reply_message.id = new byte[] { 5 }; reply_message.sign(IxianHandler.getWalletStorage().getPrimaryPrivateKey()); sendMessage(recipient, reply_message); }
// Retrieve the transaction from local cache storage private void checkTransaction() { string confirmed_text = SpixiLocalization._SL("wallet-sent-confirmed"); Transaction ctransaction = TransactionCache.getTransaction(transaction.id); if (ctransaction == null || ctransaction.applied == 0) { ctransaction = transaction; confirmed_text = SpixiLocalization._SL("wallet-sent-unconfirmed"); } IxiNumber amount = ctransaction.amount; // Convert unix timestamp string time = Utils.UnixTimeStampToString(Convert.ToDouble(ctransaction.timeStamp)); byte[] addr = new Address(ctransaction.pubKey).address; if (addr.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress())) { // this is a sent payment foreach (var entry in ctransaction.toList) { //Utils.sendUiCommand(webView, "addSender", Base58Check.Base58CheckEncoding.EncodePlain(entry.Key) + ": " + entry.Value.ToString(), time); Utils.sendUiCommand(webView, "addSender", Encoding.ASCII.GetString(ctransaction.data) + ": " + entry.Value.ToString(), time); } } Utils.sendUiCommand(webView, "setData", amount.ToString(), ctransaction.fee.ToString(), time, confirmed_text, (ctransaction.fee / ctransaction.amount).ToString() + "%", Transaction.txIdV8ToLegacy(transaction.id)); return; }
public static void sendAcceptAdd(byte[] recipient, byte[] pub_key) { Node.users.setPubKey(recipient, pub_key, false); var user = Node.users.getUser(recipient); if (user != null && user.status != BotContactStatus.banned) { user.status = BotContactStatus.normal; } SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.acceptAddBot, null); StreamMessage message = new StreamMessage(); message.type = StreamMessageCode.info; message.recipient = recipient; message.sender = IxianHandler.getWalletStorage().getPrimaryAddress(); message.data = spixi_message.getBytes(); message.encryptionType = StreamMessageEncryptionCode.none; message.id = new byte[] { 1 }; message.sign(IxianHandler.getWalletStorage().getPrimaryPrivateKey()); sendMessage(recipient, message); }
public static void onMsgDelete(byte[] msg_id, int channel, RemoteEndpoint endpoint) { StreamMessage msg = Messages.getMessage(msg_id, channel); if (msg == null) { return; } if (isAdmin(endpoint.presence.wallet) || msg.sender.SequenceEqual(endpoint.presence.wallet)) { Messages.removeMessage(msg_id, channel); SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.msgDelete, msg_id, channel); StreamMessage message = new StreamMessage(); message.type = StreamMessageCode.info; message.sender = IxianHandler.getWalletStorage().getPrimaryAddress(); message.recipient = message.sender; message.data = spixi_message.getBytes(); message.encryptionType = StreamMessageEncryptionCode.none; message.sign(IxianHandler.getWalletStorage().getPrimaryPrivateKey()); Messages.addMessage(message, channel, false); NetworkServer.forwardMessage(ProtocolMessageCode.s2data, message.getBytes()); } }
public Node() { #if DEBUG Logging.warn("Testing language files"); SpixiLocalization.testLanguageFiles("en-us"); #endif Logging.info("Initing node constructor"); Instance = this; IxianHandler.init(Config.version, this, Config.networkType); // Prepare the wallet walletStorage = new WalletStorage(Path.Combine(Config.spixiUserFolder, Config.walletFile)); PeerStorage.init(Config.spixiUserFolder); // Init TIV tiv = new TransactionInclusion(); Logging.info("Initing local storage"); // Prepare the local storage localStorage = new SPIXI.Storage.LocalStorage(Config.spixiUserFolder); customAppManager = new CustomAppManager(Config.spixiUserFolder); FriendList.init(Config.spixiUserFolder); Logging.info("Node init done"); }
static public void status() { Console.WriteLine("Last Block: {0}", IxianHandler.getLastBlockHeight()); int connectionsOut = NetworkClientManager.getConnectedClients(true).Count(); Console.WriteLine("Connections: {0}\n", connectionsOut); }
public static void sendGetMessages(Friend friend) { byte[] last_message_id = null; if (friend.messages.Count > 0) { last_message_id = friend.messages[friend.messages.Count - 1].id; } // Send the message to the S2 nodes SpixiMessage spixi_message = new SpixiMessage(new byte[] { 5 }, SpixiMessageCode.getMessages, last_message_id); StreamMessage message = new StreamMessage(); message.type = StreamMessageCode.info; message.sender = IxianHandler.getWalletStorage().getPrimaryAddress(); message.recipient = friend.walletAddress; message.data = spixi_message.getBytes(); message.transaction = new byte[1]; message.sigdata = new byte[1]; message.encryptionType = StreamMessageEncryptionCode.none; StreamProcessor.sendMessage(friend, message); }
public Node() { Instance = this; CoreConfig.productVersion = Config.version; IxianHandler.setHandler(this); CoreConfig.isTestNet = Config.isTestNet; // Initialize the crypto manager CryptoManager.initLib(); // Prepare the wallet walletStorage = new WalletStorage(Path.Combine(Config.spixiUserFolder, Config.walletFile)); string peers_filename = "peers.ixi"; if (CoreConfig.isTestNet) { peers_filename = "testnet-peers.ixi"; } PeerStorage.init(Config.spixiUserFolder, peers_filename); ulong block_height = 1; byte[] block_checksum = null; if (!walletStorage.walletExists()) { block_height = Config.bakedBlockHeight; block_checksum = Config.bakedBlockChecksum; } string headers_path = ""; if (!Config.isTestNet) { headers_path = Path.Combine(Config.spixiUserFolder, "headers"); } else { // Temporary hack for our beta testers, remove before release string tmp_path = Path.Combine(Config.spixiUserFolder, "headers"); BlockHeaderStorage.init(tmp_path); BlockHeaderStorage.deleteCache(); BlockHeaderStorage.stop(); // End of hack headers_path = Path.Combine(Config.spixiUserFolder, "testnet-headers"); } // Init TIV tiv = new TransactionInclusion(headers_path, block_height, block_checksum); // Prepare the local storage localStorage = new SPIXI.Storage.LocalStorage(Config.spixiUserFolder); customAppManager = new CustomAppManager(Config.spixiUserFolder); }
public bool sendKeys(int selected_key) { try { using (MemoryStream m = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(m)) { if (aesKey != null && selected_key != 2) { writer.Write(aesKey.Length); writer.Write(aesKey); Logging.info("Sending aes key"); } else { writer.Write(0); } if (chachaKey != null && selected_key != 1) { writer.Write(chachaKey.Length); writer.Write(chachaKey); Logging.info("Sending chacha key"); } else { writer.Write(0); } Logging.info("Preparing key message"); SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.keys, m.ToArray()); // Send the key to the recipient StreamMessage sm = new StreamMessage(); sm.type = StreamMessageCode.info; sm.recipient = walletAddress; sm.sender = Node.walletStorage.getPrimaryAddress(); sm.transaction = new byte[1]; sm.sigdata = new byte[1]; sm.data = spixi_message.getBytes(); sm.encryptionType = StreamMessageEncryptionCode.rsa; sm.id = new byte[] { 2 }; sm.sign(IxianHandler.getWalletStorage().getPrimaryPrivateKey()); StreamProcessor.sendMessage(this, sm); } } return(true); } catch (Exception e) { Logging.error(String.Format("Exception during send keys: {0}", e.Message)); } return(false); }
private void Application_Exit(object sender, ExitEventArgs e) { IxianHandler.shutdown(); while (IxianHandler.status != NodeStatus.stopped) { Thread.Sleep(10); } }
void handleBackup() { List <byte> wallet = new List <byte>(); wallet.AddRange(IxianHandler.getWalletStorage().getRawWallet()); Console.WriteLine("IXIHEX" + Crypto.hashToString(wallet.ToArray())); Console.WriteLine(""); }
public void loadTransactions() { Utils.sendUiCommand(webView, "clearRecentActivity"); lock (TransactionCache.unconfirmedTransactions) { foreach (Transaction utransaction in TransactionCache.unconfirmedTransactions) { byte[] from_address = new Address(utransaction.pubKey).address; // Filter out unrelated transactions if (from_address.SequenceEqual(friend.walletAddress) == false) { if (utransaction.toList.ContainsKey(friend.walletAddress) == false) { continue; } } string tx_type = SpixiLocalization._SL("global-received"); if (from_address.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress())) { tx_type = SpixiLocalization._SL("global-sent"); } string time = Utils.UnixTimeStampToString(Convert.ToDouble(utransaction.timeStamp)); Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(utransaction.id), tx_type, time, utransaction.amount.ToString(), "false"); } for (int i = TransactionCache.transactions.Count - 1; i >= 0; i--) { Transaction transaction = TransactionCache.transactions[i]; byte[] from_address = new Address(transaction.pubKey).address; // Filter out unrelated transactions if (from_address.SequenceEqual(friend.walletAddress) == false) { if (transaction.toList.ContainsKey(friend.walletAddress) == false) { continue; } } string tx_type = SpixiLocalization._SL("global-received"); if (from_address.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress())) { tx_type = SpixiLocalization._SL("global-sent"); } string time = Utils.UnixTimeStampToString(Convert.ToDouble(transaction.timeStamp)); string confirmed = "true"; if (transaction.applied == 0) { confirmed = "error"; } Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(transaction.id), tx_type, time, transaction.amount.ToString(), confirmed); } } }
public override void WillTerminate(UIApplication uiApplication) { IxianHandler.shutdown(); while (IxianHandler.status != NodeStatus.stopped) { Thread.Sleep(10); } base.WillTerminate(uiApplication); }
private bool processBlockHeader(BlockHeader header) { if (lastBlockHeader != null && lastBlockHeader.blockChecksum != null && !header.lastBlockChecksum.SequenceEqual(lastBlockHeader.blockChecksum)) { Logging.warn("TIV: Invalid last block checksum"); // discard the block // TODO require previous block to get verifications from 3 nodes // if in verification mode, detect liar and flag him // below is an implementation that's good enough for now if (minBlockHeightReorg < lastBlockHeader.blockNum - 7) { minBlockHeightReorg = lastBlockHeader.blockNum - 7; } BlockHeader prev_header = BlockHeaderStorage.getBlockHeader(minBlockHeightReorg); if (prev_header == null) { return(false); } lastBlockHeader = prev_header; ConsensusConfig.redactedWindowSize = ConsensusConfig.getRedactedWindowSize(lastBlockHeader.version); ConsensusConfig.minRedactedWindowSize = ConsensusConfig.getRedactedWindowSize(lastBlockHeader.version); return(false); } if (!header.calculateChecksum().SequenceEqual(header.blockChecksum)) { Logging.warn("TIV: Invalid block checksum"); return(false); } lastBlockHeader = header; ConsensusConfig.redactedWindowSize = ConsensusConfig.getRedactedWindowSize(lastBlockHeader.version); ConsensusConfig.minRedactedWindowSize = ConsensusConfig.getRedactedWindowSize(lastBlockHeader.version); if (BlockHeaderStorage.saveBlockHeader(lastBlockHeader)) { // Cleanup every n blocks if ((header.blockNum > CoreConfig.maxBlockHeadersPerDatabase * 25) && header.blockNum % CoreConfig.maxBlockHeadersPerDatabase == 0) { BlockHeaderStorage.removeAllBlocksBefore(header.blockNum - (CoreConfig.maxBlockHeadersPerDatabase * 25)); } } IxianHandler.receivedBlockHeader(lastBlockHeader, true); return(true); }
private static void acceptConnection(Socket clientSocket) { IPEndPoint clientEndpoint = (IPEndPoint)clientSocket.RemoteEndPoint; // Add timeouts and set socket options //clientSocket.ReceiveTimeout = 5000; //clientSocket.SendTimeout = 5000; clientSocket.LingerState = new LingerOption(true, 3); clientSocket.NoDelay = true; clientSocket.Blocking = true; if (!IxianHandler.isAcceptingConnections()) { Thread.Sleep(100); // wait a bit for check connectivity purposes clientSocket.Send(CoreProtocolMessage.prepareProtocolMessage(ProtocolMessageCode.bye, new byte[1])); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } lastIncomingConnectionTime = DateTime.UtcNow; connectable = true; // Setup the remote endpoint RemoteEndpoint remoteEndpoint = new RemoteEndpoint(); lock (connectedClients) { if (connectedClients.Count + 1 > CoreConfig.maximumServerMasterNodes) { Logging.warn(string.Format("Maximum number of connected clients reached. Disconnecting client: {0}:{1}", clientEndpoint.Address.ToString(), clientEndpoint.Port)); clientSocket.Send(CoreProtocolMessage.prepareProtocolMessage(ProtocolMessageCode.bye, new byte[1])); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } var existing_clients = connectedClients.Where(re => re.remoteIP.Address == clientEndpoint.Address); if (existing_clients.Count() > 0) { Logging.warn(String.Format("Client {0}:{1} already connected as {2}.", clientEndpoint.Address.ToString(), clientEndpoint.Port, existing_clients.First().ToString())); clientSocket.Send(CoreProtocolMessage.prepareProtocolMessage(ProtocolMessageCode.bye, new byte[1])); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } connectedClients.Add(remoteEndpoint); Logging.info(String.Format("Client connection accepted: {0} | #{1}/{2}", clientEndpoint.ToString(), connectedClients.Count + 1, CoreConfig.maximumServerMasterNodes)); remoteEndpoint.start(clientSocket); } }
void handleAddresses() { List <Address> address_list = IxianHandler.getWalletStorage().getMyAddresses(); foreach (Address addr in address_list) { Console.WriteLine("{0}", addr.ToString()); } Console.WriteLine(""); }
private static void acceptConnection(Socket clientSocket) { IPEndPoint clientEndpoint = (IPEndPoint)clientSocket.RemoteEndPoint; // Add timeouts and set socket options //clientSocket.ReceiveTimeout = 5000; //clientSocket.SendTimeout = 5000; clientSocket.LingerState = new LingerOption(true, 3); clientSocket.NoDelay = true; clientSocket.Blocking = true; if (!IxianHandler.isAcceptingConnections()) { CoreProtocolMessage.sendBye(clientSocket, ProtocolByeCode.notReady, string.Format("The node isn't ready yet, please try again later."), ""); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } lastIncomingConnectionTime = DateTime.UtcNow; connectable = true; // Setup the remote endpoint RemoteEndpoint remoteEndpoint = new RemoteEndpoint(); lock (connectedClients) { if (connectedClients.Count + 1 > CoreConfig.maximumServerMasterNodes) { Logging.warn("Maximum number of connected clients reached. Disconnecting client: {0}:{1}", clientEndpoint.Address.ToString(), clientEndpoint.Port); CoreProtocolMessage.sendBye(clientSocket, ProtocolByeCode.rejected, "Too many clients already connected.", ""); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } var existing_clients = connectedClients.Where(re => re.remoteIP.Address == clientEndpoint.Address); if (existing_clients.Count() > 0) { Logging.warn("Client {0}:{1} already connected as {2}.", clientEndpoint.Address.ToString(), clientEndpoint.Port, existing_clients.First().ToString()); CoreProtocolMessage.sendBye(clientSocket, ProtocolByeCode.rejected, "You are already connected.", ""); clientSocket.Shutdown(SocketShutdown.Both); clientSocket.Disconnect(true); return; } connectedClients.Add(remoteEndpoint); Logging.info("Client connection accepted: {0} | #{1}/{2}", clientEndpoint.ToString(), connectedClients.Count + 1, CoreConfig.maximumServerMasterNodes); remoteEndpoint.start(clientSocket); } }
// Generate an initial presence list public static void init(string initial_ip, int port, char type) { Logging.info("Generating presence list."); _myPublicAddress = string.Format("{0}:{1}", initial_ip, port); _myPresenceType = type; // Initialize with the default presence state curNodePresenceAddress = new PresenceAddress(CoreConfig.device_id, _myPublicAddress, type, CoreConfig.productVersion, 0, null); curNodePresence = new Presence(IxianHandler.getWalletStorage().getPrimaryAddress(), IxianHandler.getWalletStorage().getPrimaryPublicKey(), null, curNodePresenceAddress); }
public static void processPendingTransactions() { // TODO TODO improve to include failed transactions ulong last_block_height = IxianHandler.getLastBlockHeight(); lock (PendingTransactions.pendingTransactions) { long cur_time = Clock.getTimestamp(); List <PendingTransaction> tmp_pending_transactions = new List <PendingTransaction>(PendingTransactions.pendingTransactions); int idx = 0; foreach (var entry in tmp_pending_transactions) { Transaction t = entry.transaction; long tx_time = entry.addedTimestamp; if (t.applied != 0) { PendingTransactions.pendingTransactions.RemoveAll(x => x.transaction.id.SequenceEqual(t.id)); continue; } // if transaction expired, remove it from pending transactions if (last_block_height > ConsensusConfig.getRedactedWindowSize() && t.blockHeight < last_block_height - ConsensusConfig.getRedactedWindowSize()) { ActivityStorage.updateStatus(t.id, ActivityStatus.Error, 0); PendingTransactions.pendingTransactions.RemoveAll(x => x.transaction.id.SequenceEqual(t.id)); continue; } if (cur_time - tx_time > 40) // if the transaction is pending for over 40 seconds, resend { CoreProtocolMessage.broadcastProtocolMessage(new char[] { 'M', 'H' }, ProtocolMessageCode.transactionData, t.getBytes(), null); entry.addedTimestamp = cur_time; entry.confirmedNodeList.Clear(); } if (entry.confirmedNodeList.Count() >= 3) // if we get transaction from 3 nodes, we can consider it as confirmed { if (entry.messageId != null) { StreamProcessor.confirmMessage(entry.messageId); } continue; } if (cur_time - tx_time > 20) // if the transaction is pending for over 20 seconds, send inquiry { CoreProtocolMessage.broadcastGetTransaction(t.id, 0, null, false); } idx++; } } }
void handleStatus() { Console.WriteLine("Last Block Height: {0}", IxianHandler.getLastBlockHeight()); Console.WriteLine("Network Block Height: {0}", IxianHandler.getHighestKnownNetworkBlockHeight()); int connectionsOut = NetworkClientManager.getConnectedClients(true).Count(); Console.WriteLine("Connections: {0}", connectionsOut); Console.WriteLine("Pending transactions: {0}\n", PendingTransactions.pendingTransactionCount()); }
private bool handleSignature(InventoryItem item, RemoteEndpoint endpoint) { InventoryItemSignature iis = (InventoryItemSignature)item; ulong last_block_height = IxianHandler.getLastBlockHeight(); byte[] address = iis.address; ulong block_num = iis.blockNum; if (block_num + 5 > last_block_height && block_num <= last_block_height + 1) { if (block_num == last_block_height + 1) { lock (Node.blockProcessor.localBlockLock) { Block local_block = Node.blockProcessor.localNewBlock; if (local_block == null || local_block.blockNum != block_num) { return(false); } if (!local_block.blockChecksum.SequenceEqual(iis.blockHash) || local_block.hasNodeSignature(address)) { return(false); } } } else { Block sf_block = Node.blockChain.getBlock(block_num); if (!sf_block.blockChecksum.SequenceEqual(iis.blockHash) || sf_block.hasNodeSignature(address)) { return(false); } } byte[] block_num_bytes = block_num.GetIxiVarIntBytes(); byte[] addr_len_bytes = ((ulong)address.Length).GetIxiVarIntBytes(); byte[] data = new byte[block_num_bytes.Length + 1 + addr_len_bytes.Length + address.Length]; Array.Copy(block_num_bytes, data, block_num_bytes.Length); data[block_num_bytes.Length] = 1; Array.Copy(addr_len_bytes, 0, data, block_num_bytes.Length + 1, addr_len_bytes.Length); Array.Copy(address, 0, data, block_num_bytes.Length + 1 + addr_len_bytes.Length, address.Length); if (endpoint == null) { CoreProtocolMessage.broadcastProtocolMessageToSingleRandomNode(new char[] { 'M', 'H' }, ProtocolMessageCode.getSignatures, data, block_num); } else { endpoint.sendData(ProtocolMessageCode.getSignatures, data, null); } return(true); } return(false); }
public static void startProtocolTest() { Logging.info("Starting spam connect test"); if (connect()) { Logging.info("Connected."); } using (MemoryStream m = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(m)) { string publicHostname = IxianHandler.getFullPublicAddress(); // Send the public IP address and port writer.Write(publicHostname); // Send the public node address byte[] address = Node.walletStorage.getPrimaryAddress(); writer.Write(address); // Send the testnet designator writer.Write(CoreConfig.isTestNet); // Send the node type char node_type = 'M'; // This is a Master node writer.Write(node_type); // Send the node device id writer.Write(CoreConfig.device_id); // Send the wallet public key writer.Write(Node.walletStorage.getPrimaryPublicKey()); sendData(ProtocolMessageCode.hello, m.ToArray()); } } Transaction tx = new Transaction((int)Transaction.Type.PoWSolution, "0", "0", ConsensusConfig.foundationAddress, Node.walletStorage.getPrimaryAddress(), null, null, Node.blockChain.getLastBlockNum()); //byte[] data = string.Format("{0}||{1}||{2}", Node.walletStorage.publicKey, 0, 1); //tx.data = data; sendData(ProtocolMessageCode.newTransaction, tx.getBytes()); disconnect(); Logging.info("Ending spam connect test"); }