Create Testengine executable

neo-devpack-dotnet.sln

@@ -29,6 +29,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Template.NEP5.CSharp", "tem
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Template.NEP5.UnitTests", "tests\Template.NEP5.UnitTests\Template.NEP5.UnitTests.csproj", "{780141EE-D6E9-4591-8470-8F91B12027CA}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestEngine", "src\TestEngine\TestEngine.csproj", "{39347E90-FC12-4018-8F22-828F0F1B2F7D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -71,6 +73,10 @@ Global
 		{780141EE-D6E9-4591-8470-8F91B12027CA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{780141EE-D6E9-4591-8470-8F91B12027CA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{780141EE-D6E9-4591-8470-8F91B12027CA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{39347E90-FC12-4018-8F22-828F0F1B2F7D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{39347E90-FC12-4018-8F22-828F0F1B2F7D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{39347E90-FC12-4018-8F22-828F0F1B2F7D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{39347E90-FC12-4018-8F22-828F0F1B2F7D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -85,6 +91,7 @@ Global
 		{93BEC5CC-BAFF-4389-89E7-84AAFF5D495D} = {D5266066-0AFD-44D5-A83E-2F73668A63C8}
 		{ADD05222-DC45-4FDC-A41A-30A97BACC95F} = {7042EF23-826B-45A1-A905-59AD678C31B7}
 		{780141EE-D6E9-4591-8470-8F91B12027CA} = {D5266066-0AFD-44D5-A83E-2F73668A63C8}
+		{39347E90-FC12-4018-8F22-828F0F1B2F7D} = {79389FC0-C621-4CEA-AD2B-6074C32E7BCA}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {6DA935E1-C674-4364-B087-F1B511B79215}

src/TestEngine/Engine.cs

@@ -0,0 +1,98 @@
+using Neo;
+using Neo.Compiler.MSIL.UnitTests.Utils;
+using Neo.Cryptography.ECC;
+using Neo.IO.Json;
+using Neo.Network.P2P.Payloads;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using Neo.VM;
+using Neo.VM.Types;
+
+namespace TestingEngine
+{
+    public class Engine
+    {
+        private static Engine instance = null;
+        public static Engine Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new Engine();
+                }
+                return instance;
+            }
+        }
+
+        private TestEngine engine = null;
+        private byte[] PubKey => HexString2Bytes("03ea01cb94bdaf0cd1c01b159d474f9604f4af35a3e2196f6bdfdb33b2aa4961fa");
+
+        private Engine()
+        {
+            engine = SetupNativeContracts();
+        }
+
+        public void SetTestEngine(string path)
+        {
+            engine.AddEntryScript(path);
+            var manifest = ContractManifest.FromJson(JObject.Parse(engine.ScriptEntry.finalManifest));
+
+            engine.Snapshot.Contracts.Add(manifest.Hash, new Neo.Ledger.ContractState()
+            {
+                Script = engine.ScriptEntry.finalNEF,
+                Manifest = manifest,
+            });
+        }
+
+        public JObject Run(string method, StackItem[] args)
+        {
+            engine.GetMethod(method).RunEx(args);
+            return engine.ToJson();
+        }
+
+        private TestEngine SetupNativeContracts()
+        {
+            var block = new Block()
+            {
+                Index = 0,
+                ConsensusData = new ConsensusData(),
+                Transactions = new Transaction[0],
+                Witness = new Witness()
+                {
+                    InvocationScript = new byte[0],
+                    VerificationScript = Contract.CreateSignatureRedeemScript(ECPoint.FromBytes(PubKey, ECCurve.Secp256k1))
+                },
+                NextConsensus = UInt160.Zero,
+                MerkleRoot = UInt256.Zero,
+                PrevHash = UInt256.Zero
+            };
+
+            TestEngine engine = new TestEngine(TriggerType.Application, block);
+            ((TestSnapshot)engine.Snapshot).SetPersistingBlock(block);
+
+            using (var script = new ScriptBuilder())
+            {
+                script.EmitSysCall(TestEngine.Native_Deploy);
+                engine.LoadScript(script.ToArray());
+                engine.Execute();
+            }
+            engine.ClearNotifications();
+            ((TestSnapshot)engine.Snapshot).ClearStorage();
+
+            return engine;
+        }
+
+        private static byte[] HexString2Bytes(string str)
+        {
+            if (str.IndexOf("0x") == 0)
+                str = str.Substring(2);
+            byte[] outd = new byte[str.Length / 2];
+            for (var i = 0; i < str.Length / 2; i++)
+            {
+                outd[i] = byte.Parse(str.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
+            }
+            return outd;
+        }
+    }
+}

src/TestEngine/Helper.cs

@@ -0,0 +1,69 @@
+using Neo;
+using Neo.Compiler.MSIL.UnitTests.Utils;
+using Neo.IO.Caching;
+using Neo.IO.Json;
+using Neo.Ledger;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Linq;
+
+namespace TestingEngine
+{
+    public static class Helper
+    {
+        public static JObject ToJson(this TestEngine testEngine)
+        {
+            var json = new JObject();
+
+            json["vm_state"] = testEngine.State.ToString();
+            json["gas_consumed"] = (new BigDecimal(testEngine.GasConsumed, NativeContract.GAS.Decimals)).ToString();
+            json["result_stack"] = testEngine.ResultStack.ToJson();
+            json["storage"] = testEngine.Snapshot.Storages.ToJson();
+            json["notifications"] = new JArray(testEngine.Notifications.Select(n => n.ToJson()));
+            json["error"] = testEngine.State.HasFlag(VMState.FAULT) ? GetExceptionMessage(testEngine.FaultException) : null;
+
+            return json;
+        }
+
+        public static JObject ToJson(this EvaluationStack stack)
+        {
+            return new JArray(stack.Select(p => p.ToJson()));
+        }
+
+        public static JObject ToJson(this NotifyEventArgs notification)
+        {
+            var json = new JObject();
+            json["eventName"] = notification.EventName;
+            json["scriptHash"] = notification.ScriptHash.ToString();
+            json["value"] = notification.State.ToJson();
+            return json;
+        }
+
+        public static JObject ToJson(this DataCache<StorageKey, StorageItem> storage)
+        {
+            var storageMap = new Map();
+            foreach (var storagePair in storage.Seek())
+            {
+                var key = new ByteString(storagePair.Key.Key);
+                var value = new ByteString(storagePair.Value.Value);
+                storageMap[key] = value;
+            }
+            return storageMap.ToJson()["value"];
+        }
+
+        private static string GetExceptionMessage(Exception exception)
+        {
+            if (exception == null) return "Engine faulted.";
+
+            if (exception.InnerException != null)
+            {
+                return GetExceptionMessage(exception.InnerException);
+            }
+
+            return exception.Message;
+        }
+    }
+}

src/TestEngine/Program.cs

@@ -0,0 +1,134 @@
+using Neo.IO.Json;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace TestingEngine
+{
+    class Program
+    {
+        static int Main(string[] args)
+        {
+            JObject result;
+            if (args.Length >= 2)
+            {
+                result = RunWithMethodName(args[0], args[1], string.Join(" ", args.Skip(2)));
+            }
+            else
+            {
+                result = BuildJsonException("One or more arguments are missing");
+            }
+
+            Console.WriteLine(result);
+            if (!result.ContainsProperty("vm_state"))
+            {
+                return -1;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// Runs a nef script given a method name and its arguments
+        /// </summary>
+        /// <param name="path">Absolute path of the script</param>
+        /// <param name="method">The name of the targeted method</param>
+        /// <param name="parameters">Json string representing the arguments of the method</param>
+        /// <returns>Returns a json with the engine state after executing the script</returns>
+        public static JObject RunWithMethodName(string path, string methodName, string jsonParams)
+        {
+            try
+            {
+                JArray parameters = new JArray();
+                if (jsonParams.Length > 0)
+                {
+                    var json = JObject.Parse(jsonParams);
+                    if (json is JArray array)
+                    {
+                        parameters = array;
+                    }
+                    else
+                    {
+                        parameters.Insert(0, json);
+                    }
+                }
+
+                return Run(path, methodName, parameters);
+            }
+            catch (Exception e)
+            {
+                return BuildJsonException(e.Message);
+            }
+        }
+
+        /// <summary>
+        /// Runs the given method from a nef script
+        /// </summary>
+        /// <param name="path">Absolute path of the script</param>
+        /// <param name="method">The name of the targeted method</param>
+        /// <param name="parameters">Arguments of the method</param>
+        /// <returns>Returns a json with the engine state after executing the script</returns>
+        public static JObject Run(string path, string method, JArray parameters)
+        {
+            if (!File.Exists(path))
+            {
+                return BuildJsonException("File doesn't exists");
+            }
+            if (Path.GetExtension(path).ToLowerInvariant() != ".nef")
+            {
+                return BuildJsonException("Invalid file. A .nef file required.");
+            }
+
+            try
+            {
+                Engine.Instance.SetTestEngine(path);
+                var stackParams = GetStackItemParameters(parameters);
+                return Engine.Instance.Run(method, stackParams);
+            }
+            catch (Exception e)
+            {
+                return BuildJsonException(e.Message);
+            }
+        }
+
+        /// <summary>
+        /// Converts the data in a json array to an array of StackItem
+        /// </summary>
+        /// <param name="parameters">json array to be converted</param>
+        /// <returns>Returns the built StackItem array</returns>
+        private static StackItem[] GetStackItemParameters(JArray parameters)
+        {
+            var items = new List<StackItem>();
+            foreach (JObject param in parameters)
+            {
+                var success = false;
+                if (param.ContainsProperty("value") && param.ContainsProperty("type"))
+                {
+                    try
+                    {
+                        items.Add(ContractParameter.FromJson(param).ToStackItem());
+                        success = true;
+                    }
+                    catch { }
+                }
+
+                if (!success)
+                {
+                    // if something went wrong while reading the json, inserts null in this argument position
+                    items.Add(StackItem.Null);
+                }
+            }
+            return items.ToArray();
+        }
+
+        private static JObject BuildJsonException(string message)
+        {
+            var json = new JObject();
+            json["error"] = message;
+            return json;
+        }
+    }
+}

src/TestEngine/TestEngine.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Copyright>2015-2020 The Neo Project</Copyright>
+    <AssemblyTitle>Neo.TestEngine</AssemblyTitle>
+    <Version>3.0.0-preview3</Version>
+    <Authors>The Neo Project</Authors>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <PackageTags>NEO;Blockchain;Smart Contract</PackageTags>
+    <PackageProjectUrl>https://github.com/neo-project/neo-devpack-dotnet</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/neo-project/neo-devpack-dotnet.git</RepositoryUrl>
+    <RootNamespace>Neo.TestEngine</RootNamespace>
+    <Company>The Neo Project</Company>
+    <Product>TestingEngine</Product>
+    <Description>TestingEngine</Description>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Neo.Compiler.MSIL\Neo.Compiler.MSIL.csproj" />
+  </ItemGroup>
+
+</Project>

tests/Neo.Compiler.MSIL.UnitTests/Utils/BuildNEF.cs → src/TestEngine/TestUtils/BuildNEF.cs

@@ -1,8 +1,7 @@
-using Neo.Compiler.MSIL.UnitTests.Utils;
 using Neo.IO.Json;
 using Neo.SmartContract;
 
-namespace Neo.Compiler.MSIL.Utils
+namespace Neo.Compiler.MSIL.UnitTests.Utils
 {
     class BuildNEF : BuildScript
     {

tests/Neo.Compiler.MSIL.UnitTests/Utils/NeonTestTool.cs → src/TestEngine/TestUtils/NeonTestTool.cs

@@ -8,7 +8,7 @@
 [assembly: InternalsVisibleTo("Neo.SmartContract.Framework.UnitTests")]
 namespace Neo.Compiler.MSIL.UnitTests.Utils
 {
-    internal static class NeonTestTool
+    public static class NeonTestTool
     {
         /// <summary>
         /// Is not the official script hash, just a unique hash related to the script used for unit test purpose

tests/Neo.Compiler.MSIL.UnitTests/Utils/TestDataCache.cs → src/TestEngine/TestUtils/TestDataCache.cs

@@ -54,5 +54,13 @@ protected override void UpdateInternal(TKey key, TValue value)
         {
             dic[key] = value;
         }
+
+        /// <summary>
+        /// Clear the storage for unit test
+        /// </summary>
+        public void Clear()
+        {
+            dic.Clear();
+        }
     }
 }

tests/Neo.Compiler.MSIL.UnitTests/Utils/TestEngine.cs → src/TestEngine/TestUtils/TestEngine.cs

@@ -1,4 +1,3 @@
-using Neo.Compiler.MSIL.Utils;
 using Neo.IO.Json;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;