Implement NotaryAssisted transaction attribute

src/Neo.CLI/CLI/MainService.Blockchain.cs

@@ -212,6 +212,10 @@ public void OnShowTransactionCommand(UInt256 hash)
                                 ConsoleHelper.Info("", "    Type: ", $"{n.Type}");
                                 ConsoleHelper.Info("", "  Height: ", $"{n.Height}");
                                 break;
+                            case NotaryAssisted n:
+                                ConsoleHelper.Info("", "    Type: ", $"{n.Type}");
+                                ConsoleHelper.Info("", "   NKeys: ", $"{n.NKeys}");
+                                break;
                             default:
                                 ConsoleHelper.Info("", "  Type: ", $"{attribute.Type}");
                                 ConsoleHelper.Info("", "  Size: ", $"{attribute.Size} Byte(s)");

src/Neo/Hardfork.cs

@@ -16,6 +16,7 @@ public enum Hardfork : byte
         HF_Aspidochelone,
         HF_Basilisk,
         HF_Cockatrice,
-        HF_Domovoi
+        HF_Domovoi,
+        HF_Echidna,
     }
 }

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

@@ -0,0 +1,76 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// NotaryAssisted.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Json;
+using Neo.Persistence;
+using Neo.SmartContract.Native;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class NotaryAssisted : TransactionAttribute
+    {
+        /// <summary>
+        /// Native Notary contract hash stub used until native Notary contract is properly implemented.
+        /// </summary>
+        private static readonly UInt160 notaryHash = Neo.SmartContract.Helper.GetContractHash(UInt160.Zero, 0, "Notary");
+
+        /// <summary>
+        /// Indicates the number of keys participating in the transaction (main or fallback) signing process.
+        /// </summary>
+        public byte NKeys;
+
+        public override TransactionAttributeType Type => TransactionAttributeType.NotaryAssisted;
+
+        public override bool AllowMultiple => false;
+
+        public override int Size => base.Size + sizeof(byte);
+
+        protected override void DeserializeWithoutType(ref MemoryReader 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.Any(p => p.Account.Equals(notaryHash));
+        }
+
+        /// <summary>
+        /// Calculates the network fee needed to pay for NotaryAssisted attribute. According to the
+        /// https://github.com/neo-project/neo/issues/1573#issuecomment-704874472, network fee consists of
+        /// the base Notary service fee per key multiplied by the expected number of transactions that should
+        /// be collected by the service to complete Notary request increased by one (for Notary node witness
+        /// itself).
+        /// </summary>
+        /// <param name="snapshot">The snapshot used to read data.</param>
+        /// <param name="tx">The transaction to calculate.</param>
+        /// <returns>The network fee of the NotaryAssisted attribute.</returns>
+        public override long CalculateNetworkFee(DataCache snapshot, Transaction tx)
+        {
+            return (NKeys + 1) * base.CalculateNetworkFee(snapshot, tx);
+        }
+    }
+}

src/Neo/Network/P2P/Payloads/Transaction.cs

@@ -376,10 +376,13 @@ public virtual VerifyResult VerifyStateDependent(ProtocolSettings settings, Data
             if (!(context?.CheckTransaction(this, conflictsList, snapshot) ?? true)) return VerifyResult.InsufficientFunds;
             long attributesFee = 0;
             foreach (TransactionAttribute attribute in Attributes)
+            {
+                if (attribute.Type == TransactionAttributeType.NotaryAssisted && !settings.IsHardforkEnabled(Hardfork.HF_Echidna, height))
+                    return VerifyResult.InvalidAttribute;
                 if (!attribute.Verify(snapshot, this))
                     return VerifyResult.InvalidAttribute;
-                else
-                    attributesFee += attribute.CalculateNetworkFee(snapshot, this);
+                attributesFee += attribute.CalculateNetworkFee(snapshot, this);
+            }
             long netFeeDatoshi = NetworkFee - (Size * NativeContract.Policy.GetFeePerByte(snapshot)) - attributesFee;
             if (netFeeDatoshi < 0) return VerifyResult.InsufficientFunds;
 

src/Neo/Network/P2P/Payloads/TransactionAttributeType.cs

@@ -40,6 +40,12 @@ public enum TransactionAttributeType : byte
         /// Indicates that the transaction conflicts with <see cref="Conflicts.Hash"/>.
         /// </summary>
         [ReflectionCache(typeof(Conflicts))]
-        Conflicts = 0x21
+        Conflicts = 0x21,
+
+        /// <summary>
+        /// Indicates that the transaction uses notary request service with <see cref="NotaryAssisted.NKeys"/> number of keys.
+        /// </summary>
+        [ReflectionCache(typeof(NotaryAssisted))]
+        NotaryAssisted = 0x22
     }
 }

src/Neo/SmartContract/Native/GasToken.cs

@@ -43,6 +43,14 @@ internal override async ContractTask OnPersistAsync(ApplicationEngine engine)
             {
                 await Burn(engine, tx.Sender, tx.SystemFee + tx.NetworkFee);
                 totalNetworkFee += tx.NetworkFee;
+
+                // Reward for NotaryAssisted attribute will be minted to designated notary nodes
+                // by Notary contract.
+                var notaryAssisted = tx.GetAttribute<NotaryAssisted>();
+                if (notaryAssisted is not null)
+                {
+                    totalNetworkFee -= (notaryAssisted.NKeys + 1) * Policy.GetAttributeFee(engine.Snapshot, (byte)notaryAssisted.Type);
+                }
             }
             ECPoint[] validators = NEO.GetNextBlockValidators(engine.SnapshotCache, engine.ProtocolSettings.ValidatorsCount);
             UInt160 primary = Contract.CreateSignatureRedeemScript(validators[engine.PersistingBlock.PrimaryIndex]).ToScriptHash();

src/Neo/SmartContract/Native/PolicyContract.cs

@@ -44,6 +44,11 @@ public sealed class PolicyContract : NativeContract
         /// </summary>
         public const uint DefaultAttributeFee = 0;
 
+        /// <summary>
+        /// The default fee for NotaryAssisted attribute.
+        /// </summary>
+        public const uint DefaultNotaryAssistedAttributeFee = 1000_0000;
+
         /// <summary>
         /// The maximum execution fee factor that the committee can set.
         /// </summary>
@@ -85,6 +90,10 @@ internal override ContractTask InitializeAsync(ApplicationEngine engine, Hardfor
                 engine.SnapshotCache.Add(_execFeeFactor, new StorageItem(DefaultExecFeeFactor));
                 engine.SnapshotCache.Add(_storagePrice, new StorageItem(DefaultStoragePrice));
             }
+            if (hardfork == Hardfork.HF_Echidna)
+            {
+                engine.Snapshot.Add(CreateStorageKey(Prefix_AttributeFee).Add((byte)TransactionAttributeType.NotaryAssisted), new StorageItem(DefaultNotaryAssistedAttributeFee));
+            }
             return ContractTask.CompletedTask;
         }
 
@@ -122,15 +131,41 @@ public uint GetStoragePrice(DataCache snapshot)
         }
 
         /// <summary>
-        /// Gets the fee for attribute.
+        /// Gets the fee for attribute before Echidna hardfork.
+        /// </summary>
+        /// <param name="snapshot">The snapshot used to read data.</param>
+        /// <param name="attributeType">Attribute type excluding <see cref="TransactionAttributeType.NotaryAssisted"/></param>
+        /// <returns>The fee for attribute.</returns>
+        [ContractMethod(Hardfork.HF_Echidna, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.ReadStates, Name = "getAttributeFee")]
+        public uint GetAttributeFeeV0(DataCache snapshot, byte attributeType)
+        {
+            return GetAttributeFee(snapshot, attributeType, false);
+        }
+
+        /// <summary>
+        /// Gets the fee for attribute after Echidna hardfork.
         /// </summary>
         /// <param name="snapshot">The snapshot used to read data.</param>
         /// <param name="attributeType">Attribute type</param>
         /// <returns>The fee for attribute.</returns>
-        [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.ReadStates)]
+        [ContractMethod(true, Hardfork.HF_Echidna, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.ReadStates)]
         public uint GetAttributeFee(DataCache snapshot, byte attributeType)
         {
-            if (!Enum.IsDefined(typeof(TransactionAttributeType), attributeType)) throw new InvalidOperationException();
+            return GetAttributeFee(snapshot, attributeType, true);
+        }
+
+        /// <summary>
+        /// Generic handler for GetAttributeFeeV0 and GetAttributeFeeV1 that
+        /// gets the fee for attribute.
+        /// </summary>
+        /// <param name="snapshot">The snapshot used to read data.</param>
+        /// <param name="attributeType">Attribute type</param>
+        /// <param name="allowNotaryAssisted">Whether to support <see cref="TransactionAttributeType.NotaryAssisted"/> attribute type.</param>
+        /// <returns>The fee for attribute.</returns>
+        private uint GetAttributeFee(DataCache snapshot, byte attributeType, bool allowNotaryAssisted)
+        {
+            if (!Enum.IsDefined(typeof(TransactionAttributeType), attributeType) || (!allowNotaryAssisted && attributeType == (byte)(TransactionAttributeType.NotaryAssisted)))
+                throw new InvalidOperationException();
             StorageItem entry = snapshot.TryGet(CreateStorageKey(Prefix_AttributeFee).Add(attributeType));
             if (entry == null) return DefaultAttributeFee;
 
@@ -149,10 +184,45 @@ public bool IsBlocked(DataCache snapshot, UInt160 account)
             return snapshot.Contains(CreateStorageKey(Prefix_BlockedAccount).Add(account));
         }
 
-        [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States)]
-        private void SetAttributeFee(ApplicationEngine engine, byte attributeType, uint value)
+        /// <summary>
+        /// Sets the fee for attribute before Echidna hardfork.
+        /// </summary>
+        /// <param name="engine">The engine used to check committee witness and read data.</param>
+        /// <param name="attributeType">Attribute type excluding <see cref="TransactionAttributeType.NotaryAssisted"/></param>
+        /// <param name="value">Attribute fee value</param>
+        /// <returns>The fee for attribute.</returns>
+        [ContractMethod(Hardfork.HF_Echidna, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States, Name = "setAttributeFee")]
+        private void SetAttributeFeeV0(ApplicationEngine engine, byte attributeType, uint value)
+        {
+            SetAttributeFee(engine, attributeType, value, false);
+        }
+
+        /// <summary>
+        /// Sets the fee for attribute after Echidna hardfork.
+        /// </summary>
+        /// <param name="engine">The engine used to check committee witness and read data.</param>
+        /// <param name="attributeType">Attribute type excluding <see cref="TransactionAttributeType.NotaryAssisted"/></param>
+        /// <param name="value">Attribute fee value</param>
+        /// <returns>The fee for attribute.</returns>
+        [ContractMethod(true, Hardfork.HF_Echidna, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States, Name = "setAttributeFee")]
+        private void SetAttributeFeeV1(ApplicationEngine engine, byte attributeType, uint value)
+        {
+            SetAttributeFee(engine, attributeType, value, true);
+        }
+
+        /// <summary>
+        /// Generic handler for SetAttributeFeeV0 and SetAttributeFeeV1 that
+        /// gets the fee for attribute.
+        /// </summary>
+        /// <param name="engine">The engine used to check committee witness and read data.</param>
+        /// <param name="attributeType">Attribute type</param>
+        /// <param name="value">Attribute fee value</param>
+        /// <param name="allowNotaryAssisted">Whether to support <see cref="TransactionAttributeType.NotaryAssisted"/> attribute type.</param>
+        /// <returns>The fee for attribute.</returns>
+        private void SetAttributeFee(ApplicationEngine engine, byte attributeType, uint value, bool allowNotaryAssisted)
         {
-            if (!Enum.IsDefined(typeof(TransactionAttributeType), attributeType)) throw new InvalidOperationException();
+            if (!Enum.IsDefined(typeof(TransactionAttributeType), attributeType) || (!allowNotaryAssisted && attributeType == (byte)(TransactionAttributeType.NotaryAssisted)))
+                throw new InvalidOperationException();
             if (value > MaxAttributeFee) throw new ArgumentOutOfRangeException(nameof(value));
             if (!CheckCommittee(engine)) throw new InvalidOperationException();
 

src/Plugins/RpcClient/Utility.cs

@@ -207,6 +207,10 @@ public static TransactionAttribute TransactionAttributeFromJson(JObject json)
                 {
                     Hash = UInt256.Parse(json["hash"].AsString())
                 },
+                TransactionAttributeType.NotaryAssisted => new NotaryAssisted()
+                {
+                    NKeys = (byte)json["nkeys"].AsNumber()
+                },
                 _ => throw new FormatException(),
             };
         }

tests/Neo.UnitTests/Network/P2P/Payloads/UT_NotaryAssisted.cs

@@ -0,0 +1,92 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// UT_NotaryAssisted.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Extensions;
+using Neo.IO;
+using Neo.Network.P2P.Payloads;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using System;
+
+namespace Neo.UnitTests.Network.P2P.Payloads
+{
+    [TestClass]
+    public class UT_NotaryAssisted
+    {
+        // Use the hard-coded Notary hash value from NeoGo to ensure hashes are compatible.
+        private static readonly UInt160 notaryHash = UInt160.Parse("0xc1e14f19c3e60d0b9244d06dd7ba9b113135ec3b");
+
+        [TestMethod]
+        public void Size_Get()
+        {
+            var attr = new NotaryAssisted() { NKeys = 4 };
+            attr.Size.Should().Be(1 + 1);
+        }
+
+        [TestMethod]
+        public void ToJson()
+        {
+            var attr = new NotaryAssisted() { NKeys = 4 };
+            var json = attr.ToJson().ToString();
+            Assert.AreEqual(@"{""type"":""NotaryAssisted"",""nkeys"":4}", json);
+        }
+
+        [TestMethod]
+        public void DeserializeAndSerialize()
+        {
+            var attr = new NotaryAssisted() { NKeys = 4 };
+
+            var clone = attr.ToArray().AsSerializable<NotaryAssisted>();
+            Assert.AreEqual(clone.Type, attr.Type);
+
+            // As transactionAttribute
+            byte[] buffer = attr.ToArray();
+            var reader = new MemoryReader(buffer);
+            clone = TransactionAttribute.DeserializeFrom(ref reader) as NotaryAssisted;
+            Assert.AreEqual(clone.Type, attr.Type);
+
+            // Wrong type
+            buffer[0] = 0xff;
+            Assert.ThrowsException<FormatException>(() =>
+            {
+                var reader = new MemoryReader(buffer);
+                TransactionAttribute.DeserializeFrom(ref reader);
+            });
+        }
+
+        [TestMethod]
+        public void Verify()
+        {
+            var attr = new NotaryAssisted() { NKeys = 4 };
+
+            // Temporary use Notary contract hash stub for valid transaction.
+            var txGood = new Transaction { Signers = new Signer[] { new Signer() { Account = notaryHash } } };
+            var txBad = new Transaction { Signers = new Signer[] { new Signer() { Account = UInt160.Parse("0xa400ff00ff00ff00ff00ff00ff00ff00ff00ff01") } } };
+            var snapshot = TestBlockchain.GetTestSnapshotCache();
+
+            Assert.IsTrue(attr.Verify(snapshot, txGood));
+            Assert.IsFalse(attr.Verify(snapshot, txBad));
+        }
+
+        [TestMethod]
+        public void CalculateNetworkFee()
+        {
+            var snapshot = TestBlockchain.GetTestSnapshotCache();
+            var attr = new NotaryAssisted() { NKeys = 4 };
+            var tx = new Transaction { Signers = new Signer[] { new Signer() { Account = notaryHash } } };
+
+            Assert.AreEqual((4 + 1) * 1000_0000, attr.CalculateNetworkFee(snapshot, tx));
+        }
+    }
+}