Add notary contract

src/neo/Ledger/Blockchain.cs

@@ -225,6 +225,7 @@ private void OnInventory(IInventory inventory, bool relay = true)
                 Block block => OnNewBlock(block),
                 Transaction transaction => OnNewTransaction(transaction),
                 ExtensiblePayload payload => OnNewExtensiblePayload(payload),
+                NotaryRequest payload => OnNotaryRequest(payload),
                 _ => throw new NotSupportedException()
             };
             if (result == VerifyResult.Succeed && relay)
@@ -329,6 +330,13 @@ private VerifyResult OnNewExtensiblePayload(ExtensiblePayload payload)
             return VerifyResult.Succeed;
         }
 
+        private VerifyResult OnNotaryRequest(NotaryRequest payload)
+        {
+            if (!payload.Verify(system.Settings)) return VerifyResult.Invalid;
+            system.RelayCache.Add(payload);
+            return VerifyResult.Succeed;
+        }
+
         private VerifyResult OnNewTransaction(Transaction transaction)
         {
             if (system.ContainsTransaction(transaction.Hash)) return VerifyResult.AlreadyExists;

src/neo/Ledger/MemoryPool.cs

@@ -13,6 +13,7 @@
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.Plugins;
+using Neo.Wallets;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -293,6 +294,7 @@ internal VerifyResult TryAdd(Transaction tx, DataCache snapshot)
             {
                 VerifyResult result = tx.VerifyStateDependent(_system.Settings, snapshot, VerificationContext);
                 if (result != VerifyResult.Succeed) return result;
+                if (!CheckConflicts(tx)) return VerifyResult.Invalid;
 
                 _unsortedTransactions.Add(tx.Hash, poolItem);
                 VerificationContext.AddTransaction(tx);
@@ -317,6 +319,36 @@ internal VerifyResult TryAdd(Transaction tx, DataCache snapshot)
             return VerifyResult.Succeed;
         }
 
+        private bool CheckConflicts(Transaction tx)
+        {
+            List<PoolItem> to_removed = new();
+            foreach (var hash in tx.GetAttributes<ConflictAttribute>().Select(p => p.Hash))
+            {
+                if (_unsortedTransactions.TryGetValue(hash, out PoolItem item))
+                {
+                    if (!tx.Signers.Select(p => p.Account).Contains(item.Tx.Sender)) return false;
+                    if (tx.NetworkFee < item.Tx.NetworkFee) return false;
+                    to_removed.Add(item);
+                }
+            }
+            foreach (var item in _sortedTransactions)
+            {
+                var conflicts = item.Tx.GetAttributes<ConflictAttribute>().Select(p => p.Hash);
+                if (conflicts.Contains(tx.Hash))
+                {
+                    if (item.Tx.Signers.Select(p => p.Account).Contains(tx.Sender) && tx.NetworkFee < item.Tx.NetworkFee) return false;
+                    to_removed.Add(item);
+                }
+            }
+            foreach (var item in to_removed)
+            {
+                _unsortedTransactions.Remove(item.Tx.Hash);
+                _sortedTransactions.Remove(item);
+                VerificationContext.RemoveTransaction(item.Tx);
+            }
+            return true;
+        }
+
         private List<Transaction> RemoveOverCapacity()
         {
             List<Transaction> removedTransactions = new();

src/neo/Network/P2P/MessageCommand.cs

@@ -122,6 +122,12 @@ public enum MessageCommand : byte
         [ReflectionCache(typeof(Block))]
         Block = 0x2c,
 
+        /// <summary>
+        /// Sent to send an <see cref="NotaryRequest"/>.
+        /// </summary>
+        [ReflectionCache(typeof(NotaryRequest))]
+        Notary = 0x2d,
+
         /// <summary>
         /// Sent to send an <see cref="ExtensiblePayload"/>.
         /// </summary>

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

@@ -0,0 +1,45 @@
+using Neo.IO;
+using Neo.IO.Json;
+using Neo.Persistence;
+using Neo.SmartContract.Native;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    /// <summary>
+    /// Indicates that the transaction is conflict with another.
+    /// </summary>
+    public class ConflictAttribute : TransactionAttribute
+    {
+        /// <summary>
+        /// Indicates the conflict transaction hash.
+        /// </summary>
+        public UInt256 Hash;
+
+        public override TransactionAttributeType Type => TransactionAttributeType.Conflict;
+
+        public override bool AllowMultiple => true;
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            Hash = reader.ReadSerializable<UInt256>();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(Hash);
+        }
+
+        public override JObject ToJson()
+        {
+            JObject json = base.ToJson();
+            json["hash"] = Hash.ToString();
+            return json;
+        }
+
+        public override bool Verify(DataCache snapshot, Transaction tx)
+        {
+            return NativeContract.Ledger.ContainsTransaction(snapshot, Hash);
+        }
+    }
+}

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

@@ -28,6 +28,11 @@ public enum InventoryType : byte
         /// <summary>
         /// Indicates that the inventory is an <see cref="ExtensiblePayload"/>.
         /// </summary>
-        Extensible = MessageCommand.Extensible
+        Extensible = MessageCommand.Extensible,
+
+        /// <summary>
+        /// Indicates that the inventory is an <see cref="NotaryRequest"/>.
+        /// </summary>
+        Notary = MessageCommand.Notary
     }
 }

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

@@ -0,0 +1,48 @@
+using Neo.IO.Json;
+using Neo.Persistence;
+using Neo.SmartContract.Native;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    /// <summary>
+    /// Indicates that the transaction is not valid before specified height.
+    /// </summary>
+    public class NotValidBefore : TransactionAttribute
+    {
+        /// <summary>
+        /// Indicates that the transaction is not valid before this height.
+        /// </summary>
+        public uint Height;
+
+        public override TransactionAttributeType Type => TransactionAttributeType.NotValidBefore;
+
+        public override bool AllowMultiple => false;
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            Height = reader.ReadUInt32();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(Height);
+        }
+
+        public override JObject ToJson()
+        {
+            JObject json = base.ToJson();
+            json["height"] = Height;
+            return json;
+        }
+
+        public override bool Verify(DataCache snapshot, Transaction tx)
+        {
+            var maxNVBDelta = NativeContract.Notary.GetMaxNotValidBeforeDelta(snapshot);
+            var block_height = NativeContract.Ledger.CurrentIndex(snapshot);
+            if (block_height < Height) return false;
+            if ((block_height + maxNVBDelta) < Height) return false;
+            return tx.ValidUntilBlock <= (Height + maxNVBDelta);
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+using Neo.IO.Json;
+using Neo.Persistence;
+using Neo.SmartContract.Native;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Network.P2P.Payloads
+{
+    /// <summary>
+    /// Indicates that the transaction is an Notrary tx.
+    /// </summary>
+    public class NotaryAssisted : TransactionAttribute
+    {
+        /// <summary>
+        /// Indicates how many signatures the Notary need to collect.
+        /// </summary>
+        public byte NKeys;
+
+        public override TransactionAttributeType Type => TransactionAttributeType.NotaryAssisted;
+
+        public override bool AllowMultiple => false;
+
+        protected override void DeserializeWithoutType(BinaryReader reader)
+        {
+            NKeys = reader.ReadByte();
+        }
+
+        protected override void SerializeWithoutType(BinaryWriter writer)
+        {
+            writer.Write(NKeys);
+        }
+
+        public override JObject ToJson()
+        {
+            JObject json = base.ToJson();
+            json["nkeys"] = NKeys;
+            return json;
+        }
+
+        public override bool Verify(DataCache snapshot, Transaction tx)
+        {
+            return tx.Signers.First(p => p.Account.Equals(NativeContract.Notary.Hash)) is not null;
+        }
+    }
+}

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

@@ -0,0 +1,138 @@
+using Akka.Actor;
+using Neo.Cryptography;
+using Neo.IO;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.VM;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class NotaryRequest : IInventory
+    {
+        /// <summary>
+        /// Represents the fixed value of the <see cref="Transaction.Script"/> field of the fallback transaction.
+        /// </summary>
+        public static readonly byte[] FallbackFixedScript = new byte[] { (byte)OpCode.RET };
+
+        /// <summary>
+        /// The transaction need Notary to collect signatures.
+        /// </summary>
+        private Transaction mainTransaction;
+
+        /// <summary>
+        /// This transaction is valid when MainTransaction failed.
+        /// </summary>
+        private Transaction fallbackTransaction;
+
+        /// <summary>
+        /// The witness of the payload. It must be one of multi-sig address of <see cref="MainTransaction"/>.
+        /// </summary>
+        private Witness witness;
+        private UInt256 hash = null;
+
+        public InventoryType InventoryType => InventoryType.Notary;
+
+        public UInt256 Hash
+        {
+            get
+            {
+                if (hash == null)
+                {
+                    hash = this.CalculateHash();
+                }
+                return hash;
+            }
+        }
+
+        public Witness[] Witnesses
+        {
+            get
+            {
+                return new Witness[] { witness };
+            }
+            set
+            {
+                witness = value[0];
+            }
+        }
+
+        public Transaction MainTransaction
+        {
+            get => mainTransaction;
+            set
+            {
+                mainTransaction = value;
+                hash = null;
+            }
+        }
+
+        public Transaction FallbackTransaction
+        {
+            get => fallbackTransaction;
+            set
+            {
+                fallbackTransaction = value;
+                hash = null;
+            }
+        }
+
+        public int Size => mainTransaction.Size + fallbackTransaction.Size + witness.Size;
+
+
+        public void DeserializeUnsigned(BinaryReader reader)
+        {
+            mainTransaction = reader.ReadSerializable<Transaction>();
+            fallbackTransaction = reader.ReadSerializable<Transaction>();
+        }
+
+        public void Deserialize(BinaryReader reader)
+        {
+            DeserializeUnsigned(reader);
+            witness = reader.ReadSerializable<Witness>();
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            SerializeUnsigned(writer);
+            writer.Write(witness);
+        }
+
+        public void SerializeUnsigned(BinaryWriter writer)
+        {
+            writer.Write(mainTransaction);
+            writer.Write(fallbackTransaction);
+        }
+
+        public UInt160[] GetScriptHashesForVerifying(DataCache snapshot)
+        {
+            return new UInt160[] { fallbackTransaction.Signers[1].Account };
+        }
+
+        public bool Verify(ProtocolSettings settings)
+        {
+            var nKeysMain = MainTransaction.GetAttributes<NotaryAssisted>();
+            if (!nKeysMain.Any()) return false;
+            if (nKeysMain.ToArray()[0].NKeys == 0) return false;
+            if (!fallbackTransaction.Script.SequenceEqual(FallbackFixedScript)) return false;
+            if (FallbackTransaction.Signers.Length != 2) return false;
+            if (fallbackTransaction.Signers[1].Scopes != WitnessScope.None) return false;
+            if (FallbackTransaction.Witnesses[0].InvocationScript.Length != 66
+                || FallbackTransaction.Witnesses[0].VerificationScript.Length != 0
+                || (FallbackTransaction.Witnesses[0].InvocationScript[0] != (byte)OpCode.PUSHDATA1 && FallbackTransaction.Witnesses[0].InvocationScript[1] != 64))
+                return false;
+            if (FallbackTransaction.GetAttribute<NotValidBefore>() is null) return false;
+            var conflicts = FallbackTransaction.GetAttributes<ConflictAttribute>();
+            if (conflicts.Count() != 1) return false;
+            if (conflicts.ToArray()[0].Hash != MainTransaction.Hash) return false;
+            var nKeysFallback = FallbackTransaction.GetAttributes<NotaryAssisted>();
+            if (!nKeysFallback.Any()) return false;
+            if (nKeysFallback.ToArray()[0].NKeys != 0) return false;
+            if (MainTransaction.ValidUntilBlock != FallbackTransaction.ValidUntilBlock) return false;
+            if (!fallbackTransaction.VerifyWitness(settings, null, fallbackTransaction.Signers[1].Account, fallbackTransaction.Witnesses[1], 0_02000000, out _)) return false;
+            return this.VerifyWitnesses(settings, null, 0_02000000);
+        }
+    }
+}