VersionPayload optimization

neo.UnitTests/UT_P2PMessage.cs

@@ -5,7 +5,6 @@
 using Neo.Network.P2P;
 using Neo.Network.P2P.Capabilities;
 using Neo.Network.P2P.Payloads;
-using System.Collections.Generic;
 
 namespace Neo.UnitTests
 {

neo/NeoSystem.cs

@@ -73,9 +73,9 @@ public void StartConsensus(Wallet wallet, Store consensus_store = null, bool ign
             Consensus.Tell(new ConsensusService.Start { IgnoreRecoveryLogs = ignoreRecoveryLogs }, Blockchain);
         }
 
-        public void StartNode(ChannelsStartConfig cfg)
+        public void StartNode(ChannelsStartConfig config)
         {
-            start_message = cfg;
+            start_message = config;
 
             if (!suspend)
             {

neo/Network/P2P/Capabilities/NodeCapabilityType.cs

@@ -2,13 +2,11 @@
 {
     public enum NodeCapabilityType : byte
     {
-        #region Servers
-
+        //Servers
         TcpServer = 0x01,
         WsServer = 0x02,
-
-        #endregion
 
+        //Others
         FullNode = 0x10
     }
-}
+}

neo/Network/P2P/Capabilities/ServerCapability.cs

@@ -36,4 +36,4 @@ protected override void SerializeWithoutType(BinaryWriter writer)
             writer.Write(Port);
         }
     }
-}
+}

neo/Network/P2P/LocalNode.cs

@@ -1,5 +1,4 @@
 using Akka.Actor;
-using Akka.IO;
 using Neo.IO;
 using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
@@ -54,7 +53,6 @@ public LocalNode(NeoSystem system)
             {
                 if (singleton != null)
                     throw new InvalidOperationException();
-
                 this.system = system;
                 singleton = this;
             }
@@ -77,7 +75,7 @@ private static IPEndPoint GetIPEndpointFromHostPort(string hostNameOrAddress, in
             IPHostEntry entry;
             try
             {
-                entry = System.Net.Dns.GetHostEntry(hostNameOrAddress);
+                entry = Dns.GetHostEntry(hostNameOrAddress);
             }
             catch (SocketException)
             {
@@ -158,19 +156,6 @@ protected override void OnReceive(object message)
             }
         }
 
-        public NetworkAddressWithTime[] GetPeers()
-        {
-            Random rand = new Random();
-
-            return RemoteNodes.Values
-                .Where(p => p.ListenerTcpPort > 0)
-                .GroupBy(p => p.Remote.Address, (k, g) => g.First())
-                .OrderBy(p => rand.Next())
-                .Take(AddrPayload.MaxCountToSend)
-                .Select(p => NetworkAddressWithTime.Create(p.Listener, p.Version.Timestamp, p.Version.Capabilities))
-                .ToArray();
-        }
-
         private void OnRelay(IInventory inventory)
         {
             if (inventory is Transaction transaction)

neo/Network/P2P/Payloads/NetworkAddressWithTime.cs

@@ -1,7 +1,6 @@
 using Neo.IO;
 using Neo.Network.P2P.Capabilities;
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -16,13 +15,13 @@ public class NetworkAddressWithTime : ISerializable
 
         public int Size => sizeof(uint) + 16 + sizeof(ushort) + Capabilities.GetVarSize();
 
-        public static NetworkAddressWithTime Create(IPEndPoint endpoint, uint timestamp, IEnumerable<NodeCapability> capabilities)
+        public static NetworkAddressWithTime Create(IPEndPoint endpoint, uint timestamp, params NodeCapability[] capabilities)
         {
             return new NetworkAddressWithTime
             {
                 Timestamp = timestamp,
                 EndPoint = endpoint,
-                Capabilities = capabilities.ToArray()
+                Capabilities = capabilities
             };
         }
 

neo/Network/P2P/Payloads/VersionPayload.cs

@@ -1,9 +1,7 @@
 using Neo.IO;
 using Neo.Network.P2P.Capabilities;
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 
 namespace Neo.Network.P2P.Payloads
 {
@@ -14,19 +12,19 @@ public class VersionPayload : ISerializable
         public uint Magic;
         public uint Version;
         public uint Timestamp;
-        public NodeCapability[] Capabilities;
         public uint Nonce;
         public string UserAgent;
+        public NodeCapability[] Capabilities;
 
         public int Size =>
             sizeof(uint) +              // Magic
             sizeof(uint) +              // Version
             sizeof(uint) +              // Timestamp
-            Capabilities.GetVarSize() + // Capabilities
             sizeof(uint) +              // Nonce
-            UserAgent.GetVarSize();     // UserAgent
+            UserAgent.GetVarSize() +    // UserAgent
+            Capabilities.GetVarSize();  // Capabilities
 
-        public static VersionPayload Create(uint nonce, string userAgent, IEnumerable<NodeCapability> capabilities)
+        public static VersionPayload Create(uint nonce, string userAgent, params NodeCapability[] capabilities)
         {
             return new VersionPayload
             {
@@ -35,7 +33,7 @@ public static VersionPayload Create(uint nonce, string userAgent, IEnumerable<No
                 Timestamp = DateTime.Now.ToTimestamp(),
                 Nonce = nonce,
                 UserAgent = userAgent,
-                Capabilities = capabilities.ToArray(),
+                Capabilities = capabilities,
             };
         }
 
@@ -44,26 +42,23 @@ void ISerializable.Deserialize(BinaryReader reader)
             Magic = reader.ReadUInt32();
             Version = reader.ReadUInt32();
             Timestamp = reader.ReadUInt32();
+            Nonce = reader.ReadUInt32();
+            UserAgent = reader.ReadVarString(1024);
 
             // Capabilities
-
             Capabilities = new NodeCapability[reader.ReadVarInt(MaxCapabilities)];
-
             for (int x = 0, max = Capabilities.Length; x < max; x++)
                 Capabilities[x] = NodeCapability.DeserializeFrom(reader);
-
-            Nonce = reader.ReadUInt32();
-            UserAgent = reader.ReadVarString(1024);
         }
 
         void ISerializable.Serialize(BinaryWriter writer)
         {
             writer.Write(Magic);
             writer.Write(Version);
             writer.Write(Timestamp);
-            writer.Write(Capabilities);
             writer.Write(Nonce);
             writer.WriteVarString(UserAgent);
+            writer.Write(Capabilities);
         }
     }
 }

neo/Network/P2P/Peer.cs

@@ -28,7 +28,6 @@ private class WsConnected { public WebSocket Socket; public IPEndPoint Remote; p
         public const int DefaultMaxConnections = DefaultMinDesiredConnections * 4;
 
         private static readonly IActorRef tcp_manager = Context.System.Tcp();
-
         private IActorRef tcp_listener;
         private IWebHost ws_host;
         private ICancelable timer;
@@ -135,8 +134,8 @@ protected override void OnReceive(object message)
 
         private void OnStart(ChannelsStartConfig config)
         {
-            ListenerTcpPort = config.Tcp == null ? 0 : config.Tcp.Port;
-            ListenerWsPort = config.WebSocket == null ? 0 : config.WebSocket.Port;
+            ListenerTcpPort = config.Tcp?.Port ?? 0;
+            ListenerWsPort = config.WebSocket?.Port ?? 0;
 
             MinDesiredConnections = config.MinDesiredConnections;
             MaxConnections = config.MaxConnections;

neo/Network/P2P/ProtocolHandler.cs

@@ -8,6 +8,7 @@
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.Plugins;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -35,91 +36,83 @@ public ProtocolHandler(NeoSystem system)
 
         protected override void OnReceive(object message)
         {
-            switch (message)
+            if (!(message is Message msg)) return;
+            foreach (IP2PPlugin plugin in Plugin.P2PPlugins)
+                if (!plugin.OnP2PMessage(msg))
+                    return;
+            if (version == null)
             {
-                case Message msg:
-                    {
-                        foreach (IP2PPlugin plugin in Plugin.P2PPlugins)
-                            if (!plugin.OnP2PMessage(msg))
-                                return;
-
-                        if (version == null)
-                        {
-                            if (msg.Command != MessageCommand.Version)
-                                throw new ProtocolViolationException();
-                            OnVersionMessageReceived((VersionPayload)msg.Payload);
-                            return;
-                        }
-                        if (!verack)
-                        {
-                            if (msg.Command != MessageCommand.Verack)
-                                throw new ProtocolViolationException();
-                            OnVerackMessageReceived();
-                            return;
-                        }
-                        switch (msg.Command)
-                        {
-                            case MessageCommand.Addr:
-                                OnAddrMessageReceived((AddrPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Block:
-                                OnInventoryReceived((Block)msg.Payload);
-                                break;
-                            case MessageCommand.Consensus:
-                                OnInventoryReceived((ConsensusPayload)msg.Payload);
-                                break;
-                            case MessageCommand.FilterAdd:
-                                OnFilterAddMessageReceived((FilterAddPayload)msg.Payload);
-                                break;
-                            case MessageCommand.FilterClear:
-                                OnFilterClearMessageReceived();
-                                break;
-                            case MessageCommand.FilterLoad:
-                                OnFilterLoadMessageReceived((FilterLoadPayload)msg.Payload);
-                                break;
-                            case MessageCommand.GetAddr:
-                                OnGetAddrMessageReceived();
-                                break;
-                            case MessageCommand.GetBlocks:
-                                OnGetBlocksMessageReceived((GetBlocksPayload)msg.Payload);
-                                break;
-                            case MessageCommand.GetData:
-                                OnGetDataMessageReceived((InvPayload)msg.Payload);
-                                break;
-                            case MessageCommand.GetHeaders:
-                                OnGetHeadersMessageReceived((GetBlocksPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Headers:
-                                OnHeadersMessageReceived((HeadersPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Inv:
-                                OnInvMessageReceived((InvPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Mempool:
-                                OnMemPoolMessageReceived();
-                                break;
-                            case MessageCommand.Ping:
-                                OnPingMessageReceived((PingPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Pong:
-                                OnPongMessageReceived((PingPayload)msg.Payload);
-                                break;
-                            case MessageCommand.Transaction:
-                                if (msg.Payload.Size <= Transaction.MaxTransactionSize)
-                                    OnInventoryReceived((Transaction)msg.Payload);
-                                break;
-                            case MessageCommand.Verack:
-                            case MessageCommand.Version:
-                                throw new ProtocolViolationException();
-                            case MessageCommand.Alert:
-                            case MessageCommand.MerkleBlock:
-                            case MessageCommand.NotFound:
-                            case MessageCommand.Reject:
-                            default: break;
-                        }
-
-                        break;
-                    }
+                if (msg.Command != MessageCommand.Version)
+                    throw new ProtocolViolationException();
+                OnVersionMessageReceived((VersionPayload)msg.Payload);
+                return;
+            }
+            if (!verack)
+            {
+                if (msg.Command != MessageCommand.Verack)
+                    throw new ProtocolViolationException();
+                OnVerackMessageReceived();
+                return;
+            }
+            switch (msg.Command)
+            {
+                case MessageCommand.Addr:
+                    OnAddrMessageReceived((AddrPayload)msg.Payload);
+                    break;
+                case MessageCommand.Block:
+                    OnInventoryReceived((Block)msg.Payload);
+                    break;
+                case MessageCommand.Consensus:
+                    OnInventoryReceived((ConsensusPayload)msg.Payload);
+                    break;
+                case MessageCommand.FilterAdd:
+                    OnFilterAddMessageReceived((FilterAddPayload)msg.Payload);
+                    break;
+                case MessageCommand.FilterClear:
+                    OnFilterClearMessageReceived();
+                    break;
+                case MessageCommand.FilterLoad:
+                    OnFilterLoadMessageReceived((FilterLoadPayload)msg.Payload);
+                    break;
+                case MessageCommand.GetAddr:
+                    OnGetAddrMessageReceived();
+                    break;
+                case MessageCommand.GetBlocks:
+                    OnGetBlocksMessageReceived((GetBlocksPayload)msg.Payload);
+                    break;
+                case MessageCommand.GetData:
+                    OnGetDataMessageReceived((InvPayload)msg.Payload);
+                    break;
+                case MessageCommand.GetHeaders:
+                    OnGetHeadersMessageReceived((GetBlocksPayload)msg.Payload);
+                    break;
+                case MessageCommand.Headers:
+                    OnHeadersMessageReceived((HeadersPayload)msg.Payload);
+                    break;
+                case MessageCommand.Inv:
+                    OnInvMessageReceived((InvPayload)msg.Payload);
+                    break;
+                case MessageCommand.Mempool:
+                    OnMemPoolMessageReceived();
+                    break;
+                case MessageCommand.Ping:
+                    OnPingMessageReceived((PingPayload)msg.Payload);
+                    break;
+                case MessageCommand.Pong:
+                    OnPongMessageReceived((PingPayload)msg.Payload);
+                    break;
+                case MessageCommand.Transaction:
+                    if (msg.Payload.Size <= Transaction.MaxTransactionSize)
+                        OnInventoryReceived((Transaction)msg.Payload);
+                    break;
+                case MessageCommand.Verack:
+                case MessageCommand.Version:
+                    throw new ProtocolViolationException();
+                case MessageCommand.Alert:
+                case MessageCommand.MerkleBlock:
+                case MessageCommand.NotFound:
+                case MessageCommand.Reject:
+                default: break;
             }
         }
 
@@ -151,7 +144,13 @@ private void OnFilterLoadMessageReceived(FilterLoadPayload payload)
 
         private void OnGetAddrMessageReceived()
         {
-            NetworkAddressWithTime[] networkAddresses = LocalNode.Singleton.GetPeers();
+            Random rand = new Random();
+            IEnumerable<RemoteNode> peers = LocalNode.Singleton.RemoteNodes.Values
+                .Where(p => p.ListenerTcpPort > 0)
+                .GroupBy(p => p.Remote.Address, (k, g) => g.First())
+                .OrderBy(p => rand.Next())
+                .Take(AddrPayload.MaxCountToSend);
+            NetworkAddressWithTime[] networkAddresses = peers.Select(p => NetworkAddressWithTime.Create(p.Listener, p.Version.Timestamp, p.Version.Capabilities)).ToArray();
             if (networkAddresses.Length == 0) return;
             Context.Parent.Tell(Message.Create(MessageCommand.Addr, AddrPayload.Create(networkAddresses)));
         }