Merge branch 'master-n3' into telemetry

Jim8y · Neo Bot · commit 381a552e28b0 · 2025-12-11T17:48:14.000+08:00
diff --git a/README.md b/README.md
@@ -83,6 +83,9 @@
   <a href='https://coveralls.io/github/neo-project/neo'>
     <img src='https://coveralls.io/repos/github/neo-project/neo/badge.svg' alt='Coverage Status' />
   </a>
+  <a href="https://deepwiki.com/neo-project/neo">
+    <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki.">
+  </a>
   <a href="https://github.com/neo-project/neo/blob/master/LICENSE">
     <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License.">
   </a>
diff --git a/src/Neo/Ledger/MemoryPool.cs b/src/Neo/Ledger/MemoryPool.cs
@@ -117,6 +117,13 @@ public int Count
         /// </summary>
         public int UnVerifiedCount => _unverifiedTransactions.Count;
 
+        /// <summary>
+        /// Transaction policy validator function.
+        /// This function will be called to validate each transaction before adding it to the pool.
+        /// If the function returns false, the transaction will be rejected.
+        /// </summary>
+        public Func<Transaction, IReadOnlyStore, bool>? PolicyValidator { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="MemoryPool"/> class.
         /// </summary>
@@ -307,6 +314,11 @@ internal bool CanTransactionFitInPool(Transaction tx)
 
         internal VerifyResult TryAdd(Transaction tx, DataCache snapshot)
         {
+            if (PolicyValidator != null)
+            {
+                if (!PolicyValidator(tx, snapshot)) return VerifyResult.PolicyFail;
+            }
+
             var poolItem = new PoolItem(tx);
 
             if (_unsortedTransactions.ContainsKey(tx.Hash)) return VerifyResult.AlreadyInPool;
diff --git a/src/Neo/SmartContract/ApplicationEngine.Runtime.cs b/src/Neo/SmartContract/ApplicationEngine.Runtime.cs
@@ -425,7 +425,7 @@ protected internal void SendNotification(UInt160 hash, string eventName, Array s
         /// </summary>
         /// <param name="hash">The hash of the specified contract. It can be set to <see langword="null"/> to get all notifications.</param>
         /// <returns>The notifications sent during the execution.</returns>
-        protected internal Array GetNotifications(UInt160 hash)
+        protected internal Array GetNotifications(UInt160? hash)
         {
             IEnumerable<NotifyEventArgs> notifications = Notifications;
             if (hash != null) // must filter by scriptHash
diff --git a/src/Neo/SmartContract/ApplicationEngine.cs b/src/Neo/SmartContract/ApplicationEngine.cs
@@ -639,6 +639,8 @@ protected internal StackItem Convert(object? value)
         /// <returns>The converted <see cref="object"/>.</returns>
         protected internal object? Convert(StackItem item, InteropParameterDescriptor descriptor)
         {
+            if (item.IsNull && !descriptor.IsNullable && descriptor.Type != typeof(StackItem))
+                throw new InvalidOperationException($"The argument `{descriptor.Name}` can't be null.");
             descriptor.Validate(item);
             if (descriptor.IsArray)
             {
@@ -647,15 +649,24 @@ protected internal StackItem Convert(object? value)
                 {
                     av = Array.CreateInstance(descriptor.Type.GetElementType()!, array.Count);
                     for (int i = 0; i < av.Length; i++)
+                    {
+                        if (array[i].IsNull && !descriptor.IsElementNullable)
+                            throw new InvalidOperationException($"The element of `{descriptor.Name}` can't be null.");
                         av.SetValue(descriptor.Converter(array[i]), i);
+                    }
                 }
                 else
                 {
                     int count = (int)item.GetInteger();
                     if (count > Limits.MaxStackSize) throw new InvalidOperationException();
                     av = Array.CreateInstance(descriptor.Type.GetElementType()!, count);
                     for (int i = 0; i < av.Length; i++)
-                        av.SetValue(descriptor.Converter(Pop()), i);
+                    {
+                        StackItem popped = Pop();
+                        if (popped.IsNull && !descriptor.IsElementNullable)
+                            throw new InvalidOperationException($"The element of `{descriptor.Name}` can't be null.");
+                        av.SetValue(descriptor.Converter(popped), i);
+                    }
                 }
                 return av;
             }
diff --git a/src/Neo/SmartContract/InteropParameterDescriptor.cs b/src/Neo/SmartContract/InteropParameterDescriptor.cs
@@ -43,6 +43,10 @@ public class InteropParameterDescriptor
         /// </summary>
         public Func<StackItem, object?> Converter { get; }
 
+        public bool IsNullable { get; }
+
+        public bool IsElementNullable { get; }
+
         /// <summary>
         /// Indicates whether the parameter is an enumeration.
         /// </summary>
@@ -85,11 +89,25 @@ internal InteropParameterDescriptor(ParameterInfo parameterInfo)
             : this(parameterInfo.ParameterType, parameterInfo.GetCustomAttributes<ValidatorAttribute>(true).ToArray())
         {
             Name = parameterInfo.Name;
+            if (!parameterInfo.ParameterType.IsValueType)
+            {
+                var context = new NullabilityInfoContext();
+                var info = context.Create(parameterInfo);
+                if (info.ReadState == NullabilityState.Nullable)
+                    IsNullable = true;
+                if (info.ElementType?.ReadState == NullabilityState.Nullable)
+                    IsElementNullable = true;
+            }
         }
 
         internal InteropParameterDescriptor(Type type, params ValidatorAttribute[] validators)
         {
             Type = type;
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                type = type.GenericTypeArguments[0];
+                IsNullable = true;
+            }
             _validators = validators;
             if (IsEnum)
             {
diff --git a/src/Neo/SmartContract/Native/ContractManagement.cs b/src/Neo/SmartContract/Native/ContractManagement.cs
@@ -310,7 +310,7 @@ private async ContractTask<ContractState> Deploy(ApplicationEngine engine, byte[
         /// <param name="manifest">The manifest of the contract.</param>
         /// <returns>The updated contract.</returns>
         [ContractMethod(RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
-        private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] manifest)
+        private ContractTask Update(ApplicationEngine engine, byte[]? nefFile, byte[]? manifest)
         {
             return Update(engine, nefFile, manifest, StackItem.Null);
         }
@@ -324,7 +324,7 @@ private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] man
         /// <param name="data">The data of the contract.</param>
         /// <returns>The updated contract.</returns>
         [ContractMethod(RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
-        private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] manifest, StackItem data)
+        private ContractTask Update(ApplicationEngine engine, byte[]? nefFile, byte[]? manifest, StackItem data)
         {
             // Require CallFlags.All flag for post-Aspidochelone transactions, ref. #2653, #2673.
             if (engine.IsHardforkEnabled(Hardfork.HF_Aspidochelone))
diff --git a/src/Neo/SmartContract/Native/FungibleToken.cs b/src/Neo/SmartContract/Native/FungibleToken.cs
@@ -131,8 +131,6 @@ public virtual BigInteger BalanceOf(IReadOnlyStore snapshot, UInt160 account)
         [ContractMethod(CpuFee = 1 << 17, StorageFee = 50, RequiredCallFlags = CallFlags.States | CallFlags.AllowCall | CallFlags.AllowNotify)]
         private protected async ContractTask<bool> Transfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount, StackItem data)
         {
-            ArgumentNullException.ThrowIfNull(from);
-            ArgumentNullException.ThrowIfNull(to);
             if (amount.Sign < 0) throw new ArgumentOutOfRangeException(nameof(amount), "cannot be negative");
             if (!from.Equals(engine.CallingScriptHash) && !engine.CheckWitnessInternal(from))
                 return false;
diff --git a/src/Neo/SmartContract/Native/NeoToken.cs b/src/Neo/SmartContract/Native/NeoToken.cs
@@ -458,7 +458,7 @@ private bool UnregisterCandidate(ApplicationEngine engine, ECPoint pubkey)
         /// <returns><see langword="true"/> if the vote is successful; otherwise, <see langword="false"/>.</returns>
         [ContractMethod(true, Hardfork.HF_Echidna, CpuFee = 1 << 16, RequiredCallFlags = CallFlags.States)]
         [ContractMethod(Hardfork.HF_Echidna, /* */ CpuFee = 1 << 16, RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
-        private async ContractTask<bool> Vote(ApplicationEngine engine, UInt160 account, ECPoint voteTo)
+        private async ContractTask<bool> Vote(ApplicationEngine engine, UInt160 account, ECPoint? voteTo)
         {
             if (!engine.CheckWitnessInternal(account)) return false;
             return await VoteInternal(engine, account, voteTo);
diff --git a/src/Neo/SmartContract/Native/Notary.cs b/src/Neo/SmartContract/Native/Notary.cs
@@ -220,7 +220,7 @@ public BigInteger BalanceOf(DataCache snapshot, UInt160 account)
         /// <param name="to">To Account</param>
         /// <returns>Whether withdrawal was successfull.</returns>
         [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.All)]
-        private async ContractTask<bool> Withdraw(ApplicationEngine engine, UInt160 from, UInt160 to)
+        private async ContractTask<bool> Withdraw(ApplicationEngine engine, UInt160 from, UInt160? to)
         {
             if (!engine.CheckWitnessInternal(from)) return false;
             var receive = to is null ? from : to;
diff --git a/src/Neo/SmartContract/Native/StdLib.cs b/src/Neo/SmartContract/Native/StdLib.cs
@@ -234,7 +234,6 @@ private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] v
         [ContractMethod(CpuFee = 1 << 6)]
         private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] value, int start, bool backward)
         {
-            ArgumentNullException.ThrowIfNull(value);
             if (backward)
             {
                 return mem.AsSpan(0, start).LastIndexOf(value);
@@ -250,14 +249,12 @@ private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] v
         [ContractMethod(CpuFee = 1 << 8)]
         private static string[] StringSplit([MaxLength(MaxInputLength)] string str, string separator)
         {
-            ArgumentNullException.ThrowIfNull(separator);
             return str.Split(separator);
         }
 
         [ContractMethod(CpuFee = 1 << 8)]
         private static string[] StringSplit([MaxLength(MaxInputLength)] string str, string separator, bool removeEmptyEntries)
         {
-            ArgumentNullException.ThrowIfNull(separator);
             StringSplitOptions options = removeEmptyEntries ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None;
             return str.Split(separator, options);
         }
diff --git a/tests/Neo.UnitTests/Ledger/UT_MemoryPool.cs b/tests/Neo.UnitTests/Ledger/UT_MemoryPool.cs
@@ -23,6 +23,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Numerics;
 using System.Threading.Tasks;
@@ -158,6 +159,21 @@ public void CapacityTest()
             Assert.HasCount(100, _unit);
         }
 
+        [TestMethod]
+        public void CancelTest()
+        {
+            // Add over the capacity items, verify that the verified count increases each time
+
+            _unit.PolicyValidator = new Func<Transaction, IReadOnlyStore, bool>((tx, sn) => false);
+            AddTransactions(1);
+            _unit.PolicyValidator = null;
+
+            Assert.AreEqual(0, _unit.SortedTxCount);
+            Assert.AreEqual(0, _unit.VerifiedCount);
+            Assert.AreEqual(0, _unit.UnVerifiedCount);
+            Assert.HasCount(0, _unit);
+        }
+
         [TestMethod]
         public void BlockPersistMovesTxToUnverifiedAndReverification()
         {
diff --git a/tests/Neo.UnitTests/SmartContract/Native/UT_GasToken.cs b/tests/Neo.UnitTests/SmartContract/Native/UT_GasToken.cs
@@ -80,8 +80,8 @@ public async Task Check_BalanceOfTransferAndBurn()
             // Transfer
 
             Assert.IsTrue(NativeContract.NEO.Transfer(snapshot, from, to, BigInteger.Zero, true, persistingBlock));
-            Assert.ThrowsExactly<ArgumentNullException>(() => _ = NativeContract.NEO.Transfer(snapshot, from, null, BigInteger.Zero, true, persistingBlock));
-            Assert.ThrowsExactly<ArgumentNullException>(() => _ = NativeContract.NEO.Transfer(snapshot, null, to, BigInteger.Zero, false, persistingBlock));
+            Assert.ThrowsExactly<InvalidOperationException>(() => _ = NativeContract.NEO.Transfer(snapshot, from, null, BigInteger.Zero, true, persistingBlock));
+            Assert.ThrowsExactly<InvalidOperationException>(() => _ = NativeContract.NEO.Transfer(snapshot, null, to, BigInteger.Zero, false, persistingBlock));
             Assert.AreEqual(100000000, NativeContract.NEO.BalanceOf(snapshot, from));
             Assert.AreEqual(0, NativeContract.NEO.BalanceOf(snapshot, to));
 

Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ protected internal void SendNotification(UInt160 hash, string eventName, Array s`
`425`	`425`	`/// </summary>`
`426`	`426`	`/// <param name="hash">The hash of the specified contract. It can be set to <see langword="null"/> to get all notifications.</param>`
`427`	`427`	`/// <returns>The notifications sent during the execution.</returns>`
`428`		`- protected internal Array GetNotifications(UInt160 hash)`
	`428`	`+ protected internal Array GetNotifications(UInt160? hash)`
`429`	`429`	`{`
`430`	`430`	`IEnumerable<NotifyEventArgs> notifications = Notifications;`
`431`	`431`	`if (hash != null) // must filter by scriptHash`
Original file line number	Diff line number	Diff line change
`@@ -639,6 +639,8 @@ protected internal StackItem Convert(object? value)`
`639`	`639`	`/// <returns>The converted <see cref="object"/>.</returns>`
`640`	`640`	`protected internal object? Convert(StackItem item, InteropParameterDescriptor descriptor)`
`641`	`641`	`{`
	`642`	`+ if (item.IsNull && !descriptor.IsNullable && descriptor.Type != typeof(StackItem))`
	`643`	+ throw new InvalidOperationException($"The argument `{descriptor.Name}` can't be null.");
`642`	`644`	`descriptor.Validate(item);`
`643`	`645`	`if (descriptor.IsArray)`
`644`	`646`	`{`
`@@ -647,15 +649,24 @@ protected internal StackItem Convert(object? value)`
`647`	`649`	`{`
`648`	`650`	`av = Array.CreateInstance(descriptor.Type.GetElementType()!, array.Count);`
`649`	`651`	`for (int i = 0; i < av.Length; i++)`
	`652`	`+ {`
	`653`	`+ if (array[i].IsNull && !descriptor.IsElementNullable)`
	`654`	+ throw new InvalidOperationException($"The element of `{descriptor.Name}` can't be null.");
`650`	`655`	`av.SetValue(descriptor.Converter(array[i]), i);`
	`656`	`+ }`
`651`	`657`	`}`
`652`	`658`	`else`
`653`	`659`	`{`
`654`	`660`	`int count = (int)item.GetInteger();`
`655`	`661`	`if (count > Limits.MaxStackSize) throw new InvalidOperationException();`
`656`	`662`	`av = Array.CreateInstance(descriptor.Type.GetElementType()!, count);`
`657`	`663`	`for (int i = 0; i < av.Length; i++)`
`658`		`- av.SetValue(descriptor.Converter(Pop()), i);`
	`664`	`+ {`
	`665`	`+ StackItem popped = Pop();`
	`666`	`+ if (popped.IsNull && !descriptor.IsElementNullable)`
	`667`	+ throw new InvalidOperationException($"The element of `{descriptor.Name}` can't be null.");
	`668`	`+ av.SetValue(descriptor.Converter(popped), i);`
	`669`	`+ }`
`659`	`670`	`}`
`660`	`671`	`return av;`
`661`	`672`	`}`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ private async ContractTask<ContractState> Deploy(ApplicationEngine engine, byte[`
`310`	`310`	`/// <param name="manifest">The manifest of the contract.</param>`
`311`	`311`	`/// <returns>The updated contract.</returns>`
`312`	`312`	`[ContractMethod(RequiredCallFlags = CallFlags.States \| CallFlags.AllowNotify)]`
`313`		`- private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] manifest)`
	`313`	`+ private ContractTask Update(ApplicationEngine engine, byte[]? nefFile, byte[]? manifest)`
`314`	`314`	`{`
`315`	`315`	`return Update(engine, nefFile, manifest, StackItem.Null);`
`316`	`316`	`}`
`@@ -324,7 +324,7 @@ private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] man`
`324`	`324`	`/// <param name="data">The data of the contract.</param>`
`325`	`325`	`/// <returns>The updated contract.</returns>`
`326`	`326`	`[ContractMethod(RequiredCallFlags = CallFlags.States \| CallFlags.AllowNotify)]`
`327`		`- private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] manifest, StackItem data)`
	`327`	`+ private ContractTask Update(ApplicationEngine engine, byte[]? nefFile, byte[]? manifest, StackItem data)`
`328`	`328`	`{`
`329`	`329`	`// Require CallFlags.All flag for post-Aspidochelone transactions, ref. #2653, #2673.`
`330`	`330`	`if (engine.IsHardforkEnabled(Hardfork.HF_Aspidochelone))`
Original file line number	Diff line number	Diff line change
`@@ -131,8 +131,6 @@ public virtual BigInteger BalanceOf(IReadOnlyStore snapshot, UInt160 account)`
`131`	`131`	`[ContractMethod(CpuFee = 1 << 17, StorageFee = 50, RequiredCallFlags = CallFlags.States \| CallFlags.AllowCall \| CallFlags.AllowNotify)]`
`132`	`132`	`private protected async ContractTask<bool> Transfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount, StackItem data)`
`133`	`133`	`{`
`134`		`- ArgumentNullException.ThrowIfNull(from);`
`135`		`- ArgumentNullException.ThrowIfNull(to);`
`136`	`134`	`if (amount.Sign < 0) throw new ArgumentOutOfRangeException(nameof(amount), "cannot be negative");`
`137`	`135`	`if (!from.Equals(engine.CallingScriptHash) && !engine.CheckWitnessInternal(from))`
`138`	`136`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -458,7 +458,7 @@ private bool UnregisterCandidate(ApplicationEngine engine, ECPoint pubkey)`
`458`	`458`	`/// <returns><see langword="true"/> if the vote is successful; otherwise, <see langword="false"/>.</returns>`
`459`	`459`	`[ContractMethod(true, Hardfork.HF_Echidna, CpuFee = 1 << 16, RequiredCallFlags = CallFlags.States)]`
`460`	`460`	`[ContractMethod(Hardfork.HF_Echidna, /* */ CpuFee = 1 << 16, RequiredCallFlags = CallFlags.States \| CallFlags.AllowNotify)]`
`461`		`- private async ContractTask<bool> Vote(ApplicationEngine engine, UInt160 account, ECPoint voteTo)`
	`461`	`+ private async ContractTask<bool> Vote(ApplicationEngine engine, UInt160 account, ECPoint? voteTo)`
`462`	`462`	`{`
`463`	`463`	`if (!engine.CheckWitnessInternal(account)) return false;`
`464`	`464`	`return await VoteInternal(engine, account, voteTo);`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ public BigInteger BalanceOf(DataCache snapshot, UInt160 account)`
`220`	`220`	`/// <param name="to">To Account</param>`
`221`	`221`	`/// <returns>Whether withdrawal was successfull.</returns>`
`222`	`222`	`[ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.All)]`
`223`		`- private async ContractTask<bool> Withdraw(ApplicationEngine engine, UInt160 from, UInt160 to)`
	`223`	`+ private async ContractTask<bool> Withdraw(ApplicationEngine engine, UInt160 from, UInt160? to)`
`224`	`224`	`{`
`225`	`225`	`if (!engine.CheckWitnessInternal(from)) return false;`
`226`	`226`	`var receive = to is null ? from : to;`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,6 @@ private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] v`
`234`	`234`	`[ContractMethod(CpuFee = 1 << 6)]`
`235`	`235`	`private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] value, int start, bool backward)`
`236`	`236`	`{`
`237`		`- ArgumentNullException.ThrowIfNull(value);`
`238`	`237`	`if (backward)`
`239`	`238`	`{`
`240`	`239`	`return mem.AsSpan(0, start).LastIndexOf(value);`
`@@ -250,14 +249,12 @@ private static int MemorySearch([MaxLength(MaxInputLength)] byte[] mem, byte[] v`
`250`	`249`	`[ContractMethod(CpuFee = 1 << 8)]`
`251`	`250`	`private static string[] StringSplit([MaxLength(MaxInputLength)] string str, string separator)`
`252`	`251`	`{`
`253`		`- ArgumentNullException.ThrowIfNull(separator);`
`254`	`252`	`return str.Split(separator);`
`255`	`253`	`}`
`256`	`254`
`257`	`255`	`[ContractMethod(CpuFee = 1 << 8)]`
`258`	`256`	`private static string[] StringSplit([MaxLength(MaxInputLength)] string str, string separator, bool removeEmptyEntries)`
`259`	`257`	`{`
`260`		`- ArgumentNullException.ThrowIfNull(separator);`
`261`	`258`	`StringSplitOptions options = removeEmptyEntries ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None;`
`262`	`259`	`return str.Split(separator, options);`
`263`	`260`	`}`