VersionPayload optimization

neo.UnitTests/UT_P2PMessage.cs

@@ -3,6 +3,7 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.IO;
 using Neo.Network.P2P;
+using Neo.Network.P2P.Capabilities;
 using Neo.Network.P2P.Payloads;
 
 namespace Neo.UnitTests
@@ -81,12 +82,15 @@ public void Compression()
             {
                 UserAgent = "".PadLeft(1024, '0'),
                 Nonce = 1,
-                Port = 2,
-                Services = VersionServices.FullNode,
-                StartHeight = 4,
+                Magic = 2,
                 Timestamp = 5,
-                Version = 6
+                Version = 6,
+                Capabilities = new NodeCapability[]
+                {
+                    new ServerCapability(NodeCapabilityType.TcpServer, 25)
+                }
             };
+
             var msg = Message.Create(MessageCommand.Version, payload);
             var buffer = msg.ToArray();
 
@@ -100,11 +104,14 @@ public void Compression()
 
             payloadCopy.UserAgent.Should().Be(payload.UserAgent);
             payloadCopy.Nonce.Should().Be(payload.Nonce);
-            payloadCopy.Port.Should().Be(payload.Port);
-            payloadCopy.Services.Should().Be(payload.Services);
-            payloadCopy.StartHeight.Should().Be(payload.StartHeight);
+            payloadCopy.Magic.Should().Be(payload.Magic);
             payloadCopy.Timestamp.Should().Be(payload.Timestamp);
             payloadCopy.Version.Should().Be(payload.Version);
+
+            payloadCopy.Capabilities.Length.Should().Be(1);
+            ((ServerCapability)payloadCopy.Capabilities[0]).Type.Should().Be(NodeCapabilityType.TcpServer);
+            ((ServerCapability)payloadCopy.Capabilities[0]).Port.Should().Be(25);
+
         }
     }
 }

neo/NeoSystem.cs

@@ -27,7 +27,7 @@ public class NeoSystem : IDisposable
         public RpcServer RpcServer { get; private set; }
 
         private readonly Store store;
-        private Peer.Start start_message = null;
+        private ChannelsStartConfig start_message = null;
         private bool suspend = false;
 
         public NeoSystem(Store store)
@@ -73,17 +73,10 @@ public void StartConsensus(Wallet wallet, Store consensus_store = null, bool ign
             Consensus.Tell(new ConsensusService.Start { IgnoreRecoveryLogs = ignoreRecoveryLogs }, Blockchain);
         }
 
-        public void StartNode(int port = 0, int wsPort = 0, int minDesiredConnections = Peer.DefaultMinDesiredConnections,
-            int maxConnections = Peer.DefaultMaxConnections, int maxConnectionsPerAddress = 3)
+        public void StartNode(ChannelsStartConfig config)
         {
-            start_message = new Peer.Start
-            {
-                Port = port,
-                WsPort = wsPort,
-                MinDesiredConnections = minDesiredConnections,
-                MaxConnections = maxConnections,
-                MaxConnectionsPerAddress = maxConnectionsPerAddress
-            };
+            start_message = config;
+
             if (!suspend)
             {
                 LocalNode.Tell(start_message);

neo/Network/P2P/Capabilities/FullNodeCapability.cs

@@ -0,0 +1,32 @@
+using System.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public class FullNodeCapability : NodeCapability
+    {
+        public uint StartHeight;
+
+        public override int Size =>
+            base.Size +    // Type
+            sizeof(uint);  // Start Height
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="startHeight">Start Height</param>
+        public FullNodeCapability(uint startHeight = 0) : base(NodeCapabilityType.FullNode)
+        {
+            StartHeight = startHeight;
+        }
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            StartHeight = reader.ReadUInt32();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(StartHeight);
+        }
+    }
+}

neo/Network/P2P/Capabilities/NodeCapability.cs

@@ -0,0 +1,65 @@
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public abstract class NodeCapability : ISerializable
+    {
+        /// <summary>
+        /// Type
+        /// </summary>
+        public readonly NodeCapabilityType Type;
+
+        public virtual int Size => sizeof(NodeCapabilityType); // Type
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="type">Type</param>
+        protected NodeCapability(NodeCapabilityType type)
+        {
+            this.Type = type;
+        }
+
+        void ISerializable.Deserialize(BinaryReader reader)
+        {
+            if (reader.ReadByte() != (byte)Type)
+            {
+                throw new FormatException();
+            }
+
+            DeserializeWithoutType(reader);
+        }
+
+        public static NodeCapability DeserializeFrom(BinaryReader reader)
+        {
+            NodeCapability capability;
+            NodeCapabilityType type = (NodeCapabilityType)reader.ReadByte();
+            switch (type)
+            {
+                case NodeCapabilityType.TcpServer:
+                case NodeCapabilityType.WsServer:
+                    capability = new ServerCapability(type);
+                    break;
+                case NodeCapabilityType.FullNode:
+                    capability = new FullNodeCapability();
+                    break;
+                default:
+                    throw new FormatException();
+            }
+            capability.DeserializeWithoutType(reader);
+            return capability;
+        }
+
+        protected abstract void DeserializeWithoutType(BinaryReader reader);
+
+        void ISerializable.Serialize(BinaryWriter writer)
+        {
+            writer.Write((byte)Type);
+            SerializeWithoutType(writer);
+        }
+
+        protected abstract void SerializeWithoutType(BinaryWriter writer);
+    }
+}

neo/Network/P2P/Capabilities/NodeCapabilityType.cs

@@ -0,0 +1,12 @@
+namespace Neo.Network.P2P.Capabilities
+{
+    public enum NodeCapabilityType : byte
+    {
+        //Servers
+        TcpServer = 0x01,
+        WsServer = 0x02,
+
+        //Others
+        FullNode = 0x10
+    }
+}

neo/Network/P2P/Capabilities/ServerCapability.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Capabilities
+{
+    public class ServerCapability : NodeCapability
+    {
+        public ushort Port;
+
+        public override int Size =>
+            base.Size +     // Type
+            sizeof(ushort); // Port
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="type">Channel</param>
+        /// <param name="port">Port</param>
+        public ServerCapability(NodeCapabilityType type, ushort port = 0) : base(type)
+        {
+            if (type != NodeCapabilityType.TcpServer && type != NodeCapabilityType.WsServer)
+            {
+                throw new ArgumentException(nameof(type));
+            }
+
+            Port = port;
+        }
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            Port = reader.ReadUInt16();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(Port);
+        }
+    }
+}

neo/Network/P2P/ChannelsStartConfig.cs

@@ -0,0 +1,32 @@
+using System.Net;
+
+namespace Neo.Network.P2P
+{
+    public class ChannelsStartConfig
+    {
+        /// <summary>
+        /// Tcp configuration
+        /// </summary>
+        public IPEndPoint Tcp { get; set; }
+
+        /// <summary>
+        /// Web socket configuration
+        /// </summary>
+        public IPEndPoint WebSocket { get; set; }
+
+        /// <summary>
+        /// Minimum desired connections
+        /// </summary>
+        public int MinDesiredConnections { get; set; } = Peer.DefaultMinDesiredConnections;
+
+        /// <summary>
+        /// Max allowed connections
+        /// </summary>
+        public int MaxConnections { get; set; } = Peer.DefaultMaxConnections;
+
+        /// <summary>
+        /// Max allowed connections per address
+        /// </summary>
+        public int MaxConnectionsPerAddress { get; set; } = 3;
+    }
+}

neo/Network/P2P/Connection.cs

@@ -14,7 +14,6 @@ public abstract class Connection : UntypedActor
 
         public IPEndPoint Remote { get; }
         public IPEndPoint Local { get; }
-        public abstract int ListenerPort { get; }
 
         private ICancelable timer;
         private readonly IActorRef tcp;

neo/Network/P2P/LocalNode.cs

@@ -30,7 +30,7 @@ internal class SendDirectly { public IInventory Inventory; }
         public static readonly uint Nonce;
         public static string UserAgent { get; set; }
 
-        private static LocalNode singleton { get; set; }
+        private static LocalNode singleton;
         public static LocalNode Singleton
         {
             get

neo/Network/P2P/Payloads/NetworkAddressWithTime.cs

@@ -1,4 +1,5 @@
 using Neo.IO;
+using Neo.Network.P2P.Capabilities;
 using System;
 using System.IO;
 using System.Linq;
@@ -9,40 +10,42 @@ namespace Neo.Network.P2P.Payloads
     public class NetworkAddressWithTime : ISerializable
     {
         public uint Timestamp;
-        public VersionServices Services;
-        public IPEndPoint EndPoint;
+        public IPAddress Address;
+        public NodeCapability[] Capabilities;
 
-        public int Size => sizeof(uint) + sizeof(ulong) + 16 + sizeof(ushort);
+        public IPEndPoint EndPoint => new IPEndPoint(Address, Capabilities.Where(p => p.Type == NodeCapabilityType.TcpServer).Select(p => (ServerCapability)p).FirstOrDefault()?.Port ?? 0);
+        public int Size => sizeof(uint) + 16 + Capabilities.GetVarSize();
 
-        public static NetworkAddressWithTime Create(IPEndPoint endpoint, VersionServices services, uint timestamp)
+        public static NetworkAddressWithTime Create(IPAddress address, uint timestamp, params NodeCapability[] capabilities)
         {
             return new NetworkAddressWithTime
             {
                 Timestamp = timestamp,
-                Services = services,
-                EndPoint = endpoint
+                Address = address,
+                Capabilities = capabilities
             };
         }
 
         void ISerializable.Deserialize(BinaryReader reader)
         {
             Timestamp = reader.ReadUInt32();
-            Services = (VersionServices)reader.ReadUInt64();
+
+            // Address
             byte[] data = reader.ReadBytes(16);
             if (data.Length != 16) throw new FormatException();
-            IPAddress address = new IPAddress(data).Unmap();
-            data = reader.ReadBytes(2);
-            if (data.Length != 2) throw new FormatException();
-            ushort port = data.Reverse().ToArray().ToUInt16(0);
-            EndPoint = new IPEndPoint(address, port);
+            Address = new IPAddress(data).Unmap();
+
+            // Capabilities
+            Capabilities = new NodeCapability[reader.ReadVarInt(VersionPayload.MaxCapabilities)];
+            for (int x = 0, max = Capabilities.Length; x < max; x++)
+                Capabilities[x] = NodeCapability.DeserializeFrom(reader);
         }
 
         void ISerializable.Serialize(BinaryWriter writer)
         {
             writer.Write(Timestamp);
-            writer.Write((ulong)Services);
-            writer.Write(EndPoint.Address.MapToIPv6().GetAddressBytes());
-            writer.Write(BitConverter.GetBytes((ushort)EndPoint.Port).Reverse().ToArray());
+            writer.Write(Address.MapToIPv6().GetAddressBytes());
+            writer.Write(Capabilities);
         }
     }
 }