Adding some comments to P2P classes

neo/Helper.cs

@@ -248,6 +248,9 @@ internal static IPAddress Unmap(this IPAddress address)
             return address;
         }
 
+        /// <summary>
+        /// Checks IPv4 and IPv6 formats and unmap, if necessary
+        /// </summary>
         internal static IPEndPoint Unmap(this IPEndPoint endPoint)
         {
             if (!endPoint.Address.IsIPv4MappedToIPv6)

neo/Network/P2P/LocalNode.cs

@@ -122,6 +122,11 @@ public IEnumerable<IPEndPoint> GetUnconnectedPeers()
             return UnconnectedPeers;
         }
 
+        /// <summary>
+        /// Override of abstract class that is triggered when UnconnectedPeers is empty
+        /// Performs a BroadcastMessage with the command `MessageCommand.GetAddr`, which, eventually, tells all known connections
+        /// If there are no connected peers it will try with the default, respecting MaxCountFromSeedList limit
+        /// </summary>
         protected override void NeedMorePeers(int count)
         {
             count = Math.Max(count, MaxCountFromSeedList);
@@ -131,6 +136,8 @@ protected override void NeedMorePeers(int count)
             }
             else
             {
+                // Will call AddPeers with default SeedList set on Protocol.json
+                // trying to adding those to the list of currently uncconected ones
                 AddPeers(GetIPEndPointsFromSeedList(count));
             }
         }

neo/Network/P2P/Peer.cs

@@ -62,10 +62,16 @@ static Peer()
             localAddresses.UnionWith(NetworkInterface.GetAllNetworkInterfaces().SelectMany(p => p.GetIPProperties().UnicastAddresses).Select(p => p.Address.Unmap()));
         }
 
+        /// <summary>
+        /// Tries to add a set ff peers to an immutable hashset of UnconnectedPeers
+        /// </summary>
+        /// <param name="peers">Peers that the method will try to add (union) to (with) UnconnectedPeers</param>
         protected void AddPeers(IEnumerable<IPEndPoint> peers)
         {
             if (UnconnectedPeers.Count < UnconnectedMax)
             {
+                // Do not select peers to be added that are already on the ConnectedPeers
+                // If the address is the same, the ListenerTcpPort should be different
                 peers = peers.Where(p => (p.Port != ListenerTcpPort || !localAddresses.Contains(p.Address)) && !ConnectedPeers.Values.Contains(p));
                 ImmutableInterlocked.Update(ref UnconnectedPeers, p => p.Union(peers));
             }
@@ -74,6 +80,7 @@ protected void AddPeers(IEnumerable<IPEndPoint> peers)
         protected void ConnectToPeer(IPEndPoint endPoint, bool isTrusted = false)
         {
             endPoint = endPoint.Unmap();
+            // If the address is the same, the ListenerTcpPort should be different, otherwise, return
             if (endPoint.Port == ListenerTcpPort && localAddresses.Contains(endPoint.Address)) return;
 
             if (isTrusted) TrustedIpAddresses.Add(endPoint.Address);
@@ -96,6 +103,11 @@ private static bool IsIntranetAddress(IPAddress address)
             return (value & 0xff000000) == 0x0a000000 || (value & 0xff000000) == 0x7f000000 || (value & 0xfff00000) == 0xac100000 || (value & 0xffff0000) == 0xc0a80000 || (value & 0xffff0000) == 0xa9fe0000;
         }
 
+        /// <summary>
+        /// Abstract class for asking for more peers
+        /// Currently triggered when UnconnectedPeers is empty
+        /// </summary>
+        /// <param name="count">Number of peers that are being requested</param>
         protected abstract void NeedMorePeers(int count);
 
         protected override void OnReceive(object message)

neo/Network/P2P/TaskManager.cs

@@ -52,23 +52,28 @@ private void OnNewTasks(InvPayload payload)
         {
             if (!sessions.TryGetValue(Sender, out TaskSession session))
                 return;
+            // Do not accept payload of type InventoryType.TX if not synced on best known top HeaderHeight
             if (payload.Type == InventoryType.TX && Blockchain.Singleton.Height < Blockchain.Singleton.HeaderHeight)
             {
                 RequestTasks(session);
                 return;
             }
             HashSet<UInt256> hashes = new HashSet<UInt256>(payload.Hashes);
+            // Remove all previously processed knownHashes from the list that is being requested
             hashes.Remove(knownHashes);
+            // Add to AvailableTasks the ones, of type InventoryType.Block, that are global (already under processement by other sessions)
             if (payload.Type == InventoryType.Block)
                 session.AvailableTasks.UnionWith(hashes.Where(p => globalTasks.ContainsKey(p)));
 
+            // Remove those that are already in processement by other sessions
             hashes.Remove(globalTasks);
             if (hashes.Count == 0)
             {
                 RequestTasks(session);
                 return;
             }
 
+            // Update globalTasks with the ones that will be requested within this current session
             foreach (UInt256 hash in hashes)
             {
                 IncrementGlobalTask(hash);