[Neo Core Fix] Check params at Calling Contract

.devcontainer/devcontainer.dockerfile

@@ -1,3 +1,6 @@
-FROM mcr.microsoft.com/devcontainers/dotnet:9.0-noble
+# https://github.com/dotnet/dotnet-docker/blob/main/README.sdk.md
+# https://mcr.microsoft.com/en-us/artifact/mar/dotnet/sdk/tags <-- this shows all images
+FROM mcr.microsoft.com/dotnet/sdk:9.0.101-noble
+
 # Install the libleveldb-dev package 
 RUN apt-get update && apt-get install -y libleveldb-dev

benchmarks/Neo.Extensions.Benchmarks/Neo.Extensions.Benchmarks.csproj

@@ -9,7 +9,6 @@
     </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MSTest.TestFramework" Version="3.6.3" />
     <ProjectReference Include="..\..\src\Neo.Extensions\Neo.Extensions.csproj" />
     <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
   </ItemGroup>

benchmarks/Neo.VM.Benchmarks/Neo.VM.Benchmarks.csproj

@@ -9,12 +9,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MSTest.TestFramework" Version="3.6.3" />
     <ProjectReference Include="..\..\src\Neo.Extensions\Neo.Extensions.csproj" />
     <ProjectReference Include="..\..\src\Neo.Json\Neo.Json.csproj" />
     <ProjectReference Include="..\..\src\Neo.VM\Neo.VM.csproj" />
     <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
-    <ProjectReference Include="..\..\tests\Neo.VM.Tests\Neo.VM.Tests.csproj" />
   </ItemGroup>
 
 </Project>

benchmarks/Neo.VM.Benchmarks/OpCode/BenchmarkEngine.cs

@@ -9,7 +9,7 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
-using Neo.Test.Types;
+using Neo.VM.Types;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
@@ -18,12 +18,14 @@ namespace Neo.VM.Benchmark.OpCode
     /// <summary>
     /// A simple benchmark engine for <see cref="ExecutionEngine"/>.
     /// </summary>
-    public class BenchmarkEngine : TestEngine
+    public class BenchmarkEngine : ExecutionEngine
     {
         private readonly Dictionary<VM.OpCode, (int Count, TimeSpan TotalTime)> _opcodeStats = new();
         private readonly Dictionary<Script, HashSet<uint>> _breakPoints = new();
         private long _gasConsumed = 0;
 
+        public BenchmarkEngine() : base(ComposeJumpTable()) { }
+
         /// <summary>
         /// Add a breakpoint at the specified position of the specified script. The VM will break the execution when it reaches the breakpoint.
         /// </summary>
@@ -187,5 +189,23 @@ private void PrintOpcodeStats()
                                   $"Avg Time: {kvp.Value.TotalTime.TotalMilliseconds * 1000 / kvp.Value.Count,10:F2} μs");
             }
         }
+
+        private static JumpTable ComposeJumpTable()
+        {
+            JumpTable jumpTable = new JumpTable();
+            jumpTable[VM.OpCode.SYSCALL] = OnSysCall;
+            return jumpTable;
+        }
+
+        private static void OnSysCall(ExecutionEngine engine, VM.Instruction instruction)
+        {
+            uint method = instruction.TokenU32;
+            if (method == 0x77777777)
+                engine.CurrentContext!.EvaluationStack.Push(StackItem.FromInterface(new object()));
+            else if (method == 0xaddeadde)
+                engine.JumpTable.ExecuteThrow(engine, "error");
+            else
+                throw new Exception();
+        }
     }
 }

benchmarks/Neo.VM.Benchmarks/Program.cs

@@ -59,7 +59,6 @@
     }
 
     var methods = benchmarkType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
-
     foreach (var method in methods)
     {
         if (method.DeclaringType == benchmarkType && !method.GetCustomAttributes<GlobalSetupAttribute>().Any())

src/Neo/VM/Helper.cs → src/Neo/Extensions/SmartContract/ContractParameterExtensions.cs

@@ -1,6 +1,6 @@
 // Copyright (C) 2015-2024 The Neo Project.
 //
-// Helper.cs file belongs to the neo project and is free
+// ContractParameterExtensions.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
@@ -10,8 +10,6 @@
 // modifications are permitted.
 
 using Neo.Cryptography.ECC;
-using Neo.Extensions;
-using Neo.Json;
 using Neo.SmartContract;
 using Neo.VM.Types;
 using System;
@@ -20,12 +18,9 @@
 using System.Numerics;
 using Array = Neo.VM.Types.Array;
 
-namespace Neo.VM
+namespace Neo.Extensions
 {
-    /// <summary>
-    /// A helper class related to NeoVM.
-    /// </summary>
-    public static class Helper
+    public static class ContractParameterExtensions
     {
         /// <summary>
         /// Converts the <see cref="ContractParameter"/> to a <see cref="StackItem"/>.
@@ -46,7 +41,7 @@ private static StackItem ToStackItem(ContractParameter parameter, List<(StackIte
             {
                 case ContractParameterType.Array:
                     if (context is null)
-                        context = new List<(StackItem, ContractParameter)>();
+                        context = [];
                     else
                         (stackItem, _) = context.FirstOrDefault(p => ReferenceEquals(p.Item2, parameter));
                     if (stackItem is null)
@@ -57,7 +52,7 @@ private static StackItem ToStackItem(ContractParameter parameter, List<(StackIte
                     break;
                 case ContractParameterType.Map:
                     if (context is null)
-                        context = new List<(StackItem, ContractParameter)>();
+                        context = [];
                     else
                         (stackItem, _) = context.FirstOrDefault(p => ReferenceEquals(p.Item2, parameter));
                     if (stackItem is null)

src/Neo/Extensions/SmartContract/GasTokenExtensions.cs

@@ -0,0 +1,42 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// GasTokenExtensions.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.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace Neo.Extensions
+{
+    public static class GasTokenExtensions
+    {
+        public static IEnumerable<(UInt160 Address, BigInteger Balance)> GetAccounts(this GasToken gasToken, DataCache snapshot)
+        {
+            if (gasToken is null)
+                throw new ArgumentNullException(nameof(gasToken));
+
+            if (snapshot is null)
+                throw new ArgumentNullException(nameof(snapshot));
+
+            var kb = new KeyBuilder(gasToken.Id, GasToken.Prefix_Account);
+            var prefixKey = kb.ToArray();
+
+            foreach (var (key, value) in snapshot.Find(prefixKey, SeekDirection.Forward))
+            {
+                var keyBytes = key.ToArray();
+                var addressHash = new UInt160(keyBytes.AsSpan(prefixKey.Length));
+                yield return new(addressHash, value.GetInteroperable<AccountState>().Balance);
+            }
+        }
+    }
+}

src/Neo/SmartContract/ApplicationEngine.Runtime.cs

@@ -449,6 +449,7 @@ protected internal Signer[] GetCurrentSigners()
         private static bool CheckItemType(StackItem item, ContractParameterType type)
         {
             StackItemType aType = item.Type;
+            if (aType == StackItemType.Any) return true;
             if (aType == StackItemType.Pointer) return false;
             switch (type)
             {
@@ -459,7 +460,7 @@ private static bool CheckItemType(StackItem item, ContractParameterType type)
                 case ContractParameterType.Integer:
                     return aType == StackItemType.Integer;
                 case ContractParameterType.ByteArray:
-                    return aType is StackItemType.Any or StackItemType.ByteString or StackItemType.Buffer;
+                    return aType is StackItemType.ByteString or StackItemType.Buffer;
                 case ContractParameterType.String:
                     {
                         if (aType is StackItemType.ByteString or StackItemType.Buffer)
@@ -474,27 +475,23 @@ private static bool CheckItemType(StackItem item, ContractParameterType type)
                         return false;
                     }
                 case ContractParameterType.Hash160:
-                    if (aType == StackItemType.Any) return true;
                     if (aType != StackItemType.ByteString && aType != StackItemType.Buffer) return false;
                     return item.GetSpan().Length == UInt160.Length;
                 case ContractParameterType.Hash256:
-                    if (aType == StackItemType.Any) return true;
                     if (aType != StackItemType.ByteString && aType != StackItemType.Buffer) return false;
                     return item.GetSpan().Length == UInt256.Length;
                 case ContractParameterType.PublicKey:
-                    if (aType == StackItemType.Any) return true;
                     if (aType != StackItemType.ByteString && aType != StackItemType.Buffer) return false;
                     return item.GetSpan().Length == 33;
                 case ContractParameterType.Signature:
-                    if (aType == StackItemType.Any) return true;
                     if (aType != StackItemType.ByteString && aType != StackItemType.Buffer) return false;
                     return item.GetSpan().Length == 64;
                 case ContractParameterType.Array:
-                    return aType is StackItemType.Any or StackItemType.Array or StackItemType.Struct;
+                    return aType is StackItemType.Array or StackItemType.Struct;
                 case ContractParameterType.Map:
-                    return aType is StackItemType.Any or StackItemType.Map;
+                    return aType is StackItemType.Map;
                 case ContractParameterType.InteropInterface:
-                    return aType is StackItemType.Any or StackItemType.InteropInterface;
+                    return aType is StackItemType.InteropInterface;
                 default:
                     return false;
             }

src/Neo/SmartContract/ApplicationEngine.cs

@@ -325,7 +325,11 @@ private ExecutionContext CallContractInternal(ContractState contract, ContractMe
             state.CallingContext = currentContext;
 
             for (int i = args.Count - 1; i >= 0; i--)
+            {
+                if (!CheckItemType(args[i], method.Parameters[i].Type))
+                    throw new InvalidOperationException($"The type of the argument `{args[i]}` does not match the formal parameter.");
                 context_new.EvaluationStack.Push(args[i]);
+            }
 
             return context_new;
         }

src/Neo/SmartContract/Native/FungibleToken.cs

@@ -51,7 +51,7 @@ public abstract class FungibleToken<TState> : NativeContract
         /// <summary>
         /// The prefix for storing account states.
         /// </summary>
-        protected const byte Prefix_Account = 20;
+        protected internal const byte Prefix_Account = 20;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FungibleToken{TState}"/> class.

src/Neo/UInt160.cs

@@ -161,7 +161,7 @@ public static bool TryParse(string str, out UInt160 result)
                 var data = new byte[Length];
                 for (var i = 0; i < Length; i++)
                 {
-                    if (!byte.TryParse(str.AsSpan(i * 2 + startIndex, 2), NumberStyles.HexNumber, null, out data[Length - i - 1]))
+                    if (!byte.TryParse(str.AsSpan(i * 2 + startIndex, 2), NumberStyles.AllowHexSpecifier, null, out data[Length - i - 1]))
                         return false;
                 }
                 result = new(data);

src/Plugins/RpcServer/RpcException.cs

@@ -15,9 +15,17 @@ namespace Neo.Plugins.RpcServer
 {
     public class RpcException : Exception
     {
+        private readonly RpcError _rpcError;
+
         public RpcException(RpcError error) : base(error.ErrorMessage)
         {
             HResult = error.Code;
+            _rpcError = error;
+        }
+
+        public RpcError GetError()
+        {
+            return _rpcError;
         }
     }
 }

src/Plugins/RpcServer/RpcServer.cs

@@ -274,7 +274,7 @@ public async Task ProcessAsync(HttpContext context)
             await context.Response.WriteAsync(response.ToString(), Encoding.UTF8);
         }
 
-        private async Task<JObject> ProcessRequestAsync(HttpContext context, JObject request)
+        internal async Task<JObject> ProcessRequestAsync(HttpContext context, JObject request)
         {
             if (!request.ContainsProperty("id")) return null;
             var @params = request["params"] ?? new JArray();
@@ -315,11 +315,13 @@ private async Task<JObject> ProcessRequestAsync(HttpContext context, JObject req
                             {
                                 if (param.ParameterType == typeof(UInt160))
                                 {
-                                    args[i] = ParameterConverter.ConvertUInt160(jsonParameters[i], system.Settings.AddressVersion);
+                                    args[i] = ParameterConverter.ConvertUInt160(jsonParameters[i],
+                                        system.Settings.AddressVersion);
                                 }
                                 else
                                 {
-                                    args[i] = ParameterConverter.ConvertParameter(jsonParameters[i], param.ParameterType);
+                                    args[i] = ParameterConverter.ConvertParameter(jsonParameters[i],
+                                        param.ParameterType);
                                 }
                             }
                             catch (Exception e) when (e is not RpcException)
@@ -333,7 +335,8 @@ private async Task<JObject> ProcessRequestAsync(HttpContext context, JObject req
                             {
                                 args[i] = param.DefaultValue;
                             }
-                            else if (param.ParameterType.IsValueType && Nullable.GetUnderlyingType(param.ParameterType) == null)
+                            else if (param.ParameterType.IsValueType &&
+                                     Nullable.GetUnderlyingType(param.ParameterType) == null)
                             {
                                 throw new ArgumentException($"Required parameter '{param.Name}' is missing");
                             }
@@ -366,11 +369,23 @@ private async Task<JObject> ProcessRequestAsync(HttpContext context, JObject req
             catch (Exception ex) when (ex is not RpcException)
             {
 #if DEBUG
-                return CreateErrorResponse(request["id"], RpcErrorFactory.NewCustomError(ex.HResult, ex.Message, ex.StackTrace));
+                return CreateErrorResponse(request["id"],
+                    RpcErrorFactory.NewCustomError(ex.HResult, ex.Message, ex.StackTrace));
 #else
         return CreateErrorResponse(request["id"], RpcErrorFactory.NewCustomError(ex.HResult, ex.Message));
 #endif
             }
+            catch (RpcException ex)
+            {
+
+#if DEBUG
+                return CreateErrorResponse(request["id"],
+                    RpcErrorFactory.NewCustomError(ex.HResult, ex.Message, ex.StackTrace));
+#else
+                return CreateErrorResponse(request["id"], ex.GetError());
+#endif
+
+            }
         }
 
         public void RegisterMethods(object handler)