Allow plugins to send custom messages

src/neo/Network/P2P/MessageCommand.cs

@@ -40,6 +40,8 @@ public enum MessageCommand : byte
         Block = 0x2c,
         [ReflectionCache(typeof(ConsensusPayload))]
         Consensus = 0x2d,
+        [ReflectionCache(typeof(PluginPayload))]
+        Plugin = 0x2e,
         Reject = 0x2f,
 
         //SPV protocol

src/neo/Network/P2P/Payloads/PluginPayload.cs

@@ -0,0 +1,110 @@
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.SmartContract.Native.Designate;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class PluginPayload : IVerifiable
+    {
+        public string Plugin;
+        public byte MessageType;
+        public byte[] Data;
+        public PluginPayloadRole WitnessRole;
+        public Witness Witness;
+
+        private UInt256 _hash = null;
+        public UInt256 Hash
+        {
+            get
+            {
+                if (_hash == null)
+                {
+                    _hash = this.CalculateHash();
+                }
+                return _hash;
+            }
+        }
+
+        public int Size =>
+            Plugin.GetVarSize() +   //Plugin
+            sizeof(byte) +          //MessageType
+            sizeof(PluginPayloadRole) +          //WitnessRole
+            Data.GetVarSize() +     //Data
+            1 + Witness.Size;       //Witness
+
+        Witness[] IVerifiable.Witnesses
+        {
+            get
+            {
+                return new[] { Witness };
+            }
+            set
+            {
+                if (value.Length != 1) throw new ArgumentException();
+                Witness = value[0];
+            }
+        }
+
+        void ISerializable.Deserialize(BinaryReader reader)
+        {
+            ((IVerifiable)this).DeserializeUnsigned(reader);
+            if (reader.ReadByte() != 1) throw new FormatException();
+            Witness = reader.ReadSerializable<Witness>();
+        }
+
+        void IVerifiable.DeserializeUnsigned(BinaryReader reader)
+        {
+            Plugin = reader.ReadVarString(32);
+            MessageType = reader.ReadByte();
+            Data = reader.ReadVarBytes(ushort.MaxValue);
+            WitnessRole = (PluginPayloadRole)reader.ReadByte();
+            if (!Enum.IsDefined(typeof(PluginPayloadRole), WitnessRole)) throw new FormatException();
+        }
+
+        UInt160[] IVerifiable.GetScriptHashesForVerifying(StoreView snapshot)
+        {
+            switch (WitnessRole)
+            {
+                case PluginPayloadRole.Committee:
+                    {
+                        return new[] { NativeContract.NEO.GetCommitteeAddress(snapshot) };
+                    }
+                case PluginPayloadRole.Validators:
+                    {
+                        return new[] { Blockchain.GetConsensusAddress(NativeContract.NEO.GetNextBlockValidators(snapshot)) };
+                    }
+                case PluginPayloadRole.StateValidator:
+                case PluginPayloadRole.Oracle:
+                    {
+                        return new[] { Blockchain.GetConsensusAddress(NativeContract.Designate.GetDesignatedByRole(snapshot, (Role)WitnessRole, snapshot.Height)) };
+                    }
+            }
+
+            throw new ArgumentException();
+        }
+
+        void ISerializable.Serialize(BinaryWriter writer)
+        {
+            ((IVerifiable)this).SerializeUnsigned(writer);
+            writer.Write((byte)1); writer.Write(Witness);
+        }
+
+        void IVerifiable.SerializeUnsigned(BinaryWriter writer)
+        {
+            writer.WriteVarString(Plugin);
+            writer.Write(MessageType);
+            writer.WriteVarBytes(Data);
+            writer.Write((byte)WitnessRole);
+        }
+
+        public bool Verify(StoreView snapshot)
+        {
+            return this.VerifyWitnesses(snapshot, 0_02000000);
+        }
+    }
+}

src/neo/Network/P2P/Payloads/PluginPayloadRole.cs

@@ -0,0 +1,10 @@
+namespace Neo.Network.P2P.Payloads
+{
+    public enum PluginPayloadRole : byte
+    {
+        Committee = 0,
+        Validators = 2,
+        StateValidator = 4,
+        Oracle = 8
+    }
+}

src/neo/Network/P2P/RemoteNode.ProtocolHandler.cs

@@ -39,6 +39,12 @@ protected override UInt256 GetKeyForItem((UInt256, DateTime) item)
 
         private void OnMessage(Message msg)
         {
+            if (msg.Command == MessageCommand.Plugin)
+            {
+                var payload = (PluginPayload)msg.Payload;
+                if (!knownHashes.Add(payload.Hash)) return;
+                if (!payload.Verify(Blockchain.Singleton.GetSnapshot())) return;
+            }
             foreach (IP2PPlugin plugin in Plugin.P2PPlugins)
                 if (!plugin.OnP2PMessage(msg))
                     return;
@@ -107,6 +113,9 @@ private void OnMessage(Message msg)
                     if (msg.Payload.Size <= Transaction.MaxTransactionSize)
                         OnInventoryReceived((Transaction)msg.Payload);
                     break;
+                case MessageCommand.Plugin:
+                    OnPluginMessage(msg);
+                    break;
                 case MessageCommand.Verack:
                 case MessageCommand.Version:
                     throw new ProtocolViolationException();
@@ -119,6 +128,11 @@ private void OnMessage(Message msg)
             }
         }
 
+        private void OnPluginMessage(Message msg)
+        {
+            system.LocalNode.Tell(msg);
+        }
+
         private void OnAddrMessageReceived(AddrPayload payload)
         {
             ref bool sent = ref sentCommands[(byte)MessageCommand.GetAddr];