Allow plugins to send custom messages

src/neo/Ledger/Blockchain.cs

@@ -10,10 +10,12 @@
 using Neo.Persistence;
 using Neo.Plugins;
 using Neo.SmartContract;
+using Neo.SmartContract.Native;
 using Neo.VM;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 
@@ -66,6 +68,7 @@ public class RelayResult { public IInventory Inventory; public VerifyResult Resu
  private readonly Dictionary<uint, UnverifiedBlocksList> block_cache_unverified = new Dictionary<uint, UnverifiedBlocksList>();
  internal readonly RelayCache RelayCache = new RelayCache(100);
  private SnapshotView currentSnapshot;
+ private ImmutableHashSet<UInt160> extensibleWitnessWhiteList;
 
  public IStore Store { get; }
  public ReadOnlyView View { get; }
@@ -517,6 +520,29 @@ private void SendRelayResult(IInventory inventory, VerifyResult result)
  private void UpdateCurrentSnapshot()
  {
  Interlocked.Exchange(ref currentSnapshot, GetSnapshot())?.Dispose();
+ var builder = ImmutableHashSet.CreateBuilder<UInt160>();
+ builder.Add(NativeContract.NEO.GetCommitteeAddress(currentSnapshot));
+ var validators = NativeContract.NEO.GetNextBlockValidators(currentSnapshot);
+ builder.Add(GetConsensusAddress(validators));
+ builder.UnionWith(validators.Select(u => Contract.CreateSignatureRedeemScript(u).ToScriptHash()));
+ var oracles = NativeContract.RoleManagement.GetDesignatedByRole(currentSnapshot, Role.Oracle, currentSnapshot.Height);
+ if (oracles.Length > 0)
+ {
+ builder.Add(GetConsensusAddress(oracles));
+ builder.UnionWith(oracles.Select(u => Contract.CreateSignatureRedeemScript(u).ToScriptHash()));
+ }
+ var stateValidators = NativeContract.RoleManagement.GetDesignatedByRole(currentSnapshot, Role.StateValidator, currentSnapshot.Height);
+ if (stateValidators.Length > 0)
+ {
+ builder.Add(GetConsensusAddress(stateValidators));
+ builder.UnionWith(stateValidators.Select(u => Contract.CreateSignatureRedeemScript(u).ToScriptHash()));
+ }
+ extensibleWitnessWhiteList = builder.ToImmutable();
+ }
+
+ internal bool IsExtensibleWitnessWhiteListed(UInt160 address)
+ {
+ return extensibleWitnessWhiteList.Contains(address);
  }
  }
 

src/neo/Network/P2P/Message.cs

@@ -39,6 +39,7 @@ public static Message Create(MessageCommand command, ISerializable payload = nul
  bool tryCompression =
  command == MessageCommand.Block ||
  command == MessageCommand.Consensus ||
+ command == MessageCommand.Extensible ||
  command == MessageCommand.Transaction ||
  command == MessageCommand.Headers ||
  command == MessageCommand.Addr ||

src/neo/Network/P2P/MessageCommand.cs

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

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

@@ -0,0 +1,98 @@
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Persistence;
+using Neo.SmartContract;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+ public class ExtensiblePayload : IInventory
+ {
+ public string Receiver;
+ public byte MessageType;
+ public uint ValidBlockStart;
+ public uint ValidBlockEnd;
+ public byte[] Data;
+ public Witness Witness;
+
+ private UInt256 _hash = null;
+ public UInt256 Hash
+ {
+ get
+ {
+ if (_hash == null)
+ {
+ _hash = this.CalculateHash();
+ }
+ return _hash;
+ }
+ }
+
+ InventoryType IInventory.InventoryType => InventoryType.Extensible;
+
+ public int Size =>
+ Receiver.GetVarSize() + //Receiver
+ sizeof(byte) + //MessageType
+ sizeof(uint) + //ValidBlockStart
+ sizeof(uint) + //ValidBlockEnd
+ 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)
+ {
+ Receiver = reader.ReadVarString(32);
+ MessageType = reader.ReadByte();
+ ValidBlockStart = reader.ReadUInt32();
+ ValidBlockEnd = reader.ReadUInt32();
+ Data = reader.ReadVarBytes(ushort.MaxValue);
+ }
+
+ UInt160[] IVerifiable.GetScriptHashesForVerifying(StoreView snapshot)
+ {
+ return new[] { Witness.ScriptHash }; // This address should be checked by consumer
+ }
+
+ void ISerializable.Serialize(BinaryWriter writer)
+ {
+ ((IVerifiable)this).SerializeUnsigned(writer);
+ writer.Write((byte)1); writer.Write(Witness);
+ }
+
+ void IVerifiable.SerializeUnsigned(BinaryWriter writer)
+ {
+ writer.WriteVarString(Receiver);
+ writer.Write(MessageType);
+ writer.Write(ValidBlockStart);
+ writer.Write(ValidBlockEnd);
+ writer.WriteVarBytes(Data);
+ }
+
+ public bool Verify(StoreView snapshot)
+ {
+ if (snapshot.PersistingBlock.Index < ValidBlockStart || snapshot.PersistingBlock.Index > ValidBlockEnd) return false;
+ if (!Blockchain.Singleton.IsExtensibleWitnessWhiteListed(Witness.ScriptHash)) return false;
+ return this.VerifyWitnesses(snapshot, 0_02000000);
+ }
+ }
+}

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

@@ -4,6 +4,7 @@ public enum InventoryType : byte
  {
  TX = MessageCommand.Transaction,
  Block = MessageCommand.Block,
+ Extensible = MessageCommand.Extensible,
  Consensus = MessageCommand.Consensus
  }
 }

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.Extensible)
+ {
+ var payload = (ExtensiblePayload)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;
@@ -67,6 +73,9 @@ private void OnMessage(Message msg)
  case MessageCommand.Consensus:
  OnInventoryReceived((ConsensusPayload)msg.Payload);
  break;
+ case MessageCommand.Extensible:
+ OnInventoryReceived((ExtensiblePayload)msg.Payload);
+ break;
  case MessageCommand.FilterAdd:
  OnFilterAddMessageReceived((FilterAddPayload)msg.Payload);
  break;

src/neo/Network/P2P/RemoteNode.cs

@@ -87,6 +87,7 @@ private void EnqueueMessage(Message message)
  {
  case MessageCommand.Alert:
  case MessageCommand.Consensus:
+ case MessageCommand.Extensible:
  case MessageCommand.FilterAdd:
  case MessageCommand.FilterClear:
  case MessageCommand.FilterLoad:
@@ -223,6 +224,7 @@ internal protected override bool IsHighPriority(object message)
  switch (msg.Command)
  {
  case MessageCommand.Consensus:
+ case MessageCommand.Extensible:
  case MessageCommand.FilterAdd:
  case MessageCommand.FilterClear:
  case MessageCommand.FilterLoad:

src/neo/Network/P2P/TaskManager.cs

@@ -342,7 +342,7 @@ internal protected override bool IsHighPriority(object message)
  case TaskManager.RestartTasks _:
  return true;
  case TaskManager.NewTasks tasks:
- if (tasks.Payload.Type == InventoryType.Block || tasks.Payload.Type == InventoryType.Consensus)
+ if (tasks.Payload.Type == InventoryType.Block || tasks.Payload.Type == InventoryType.Consensus || tasks.Payload.Type == InventoryType.Extensible)
  return true;
  return false;
  default:

tests/neo.UnitTests/Network/P2P/Payloads/UT_ExtensiblePayload.cs

@@ -0,0 +1,44 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.IO;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.UnitTests.Network.P2P.Payloads
+{
+ [TestClass]
+ public class UT_ExtensiblePayload
+ {
+ [TestMethod]
+ public void Size_Get()
+ {
+ var test = new ExtensiblePayload()
+ {
+ Receiver = "123",
+ Data = new byte[] { 1, 2, 3 },
+ Witness = new Witness() { InvocationScript = new byte[] { 3, 5, 6 }, VerificationScript = new byte[0] }
+ };
+ test.Size.Should().Be(23);
+ }
+
+ [TestMethod]
+ public void DeserializeAndSerialize()
+ {
+ var test = new ExtensiblePayload()
+ {
+ Receiver = "123",
+ MessageType = 123,
+ ValidBlockEnd = 456,
+ ValidBlockStart = 789,
+ Data = new byte[] { 1, 2, 3 },
+ Witness = new Witness() { InvocationScript = new byte[] { 3, 5, 6 }, VerificationScript = new byte[0] }
+ };
+ var clone = test.ToArray().AsSerializable<ExtensiblePayload>();
+
+ Assert.AreEqual(test.Hash, clone.Hash);
+ Assert.AreEqual(test.ValidBlockStart, clone.ValidBlockStart);
+ Assert.AreEqual(test.ValidBlockEnd, clone.ValidBlockEnd);
+ Assert.AreEqual(test.Receiver, clone.Receiver);
+ Assert.AreEqual(test.MessageType, clone.MessageType);
+ }
+ }
+}