Feature manifest and permission system

neo.UnitTests/UT_ContractManifest.cs

@@ -0,0 +1,85 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Cryptography.ECC;
+using Neo.SmartContract.Manifest;
+
+namespace Neo.UnitTests
+{
+    [TestClass]
+    public class UT_ContractManifest
+    {
+        [TestMethod]
+        public void ParseFromJson_Default()
+        {
+            var json = @"{""groups"":[],""features"":{""storage"":false,""payable"":false},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":""*"",""trusts"":[],""safeMethods"":[]}";
+            var manifest = ContractManifest.Parse(json);
+
+            Assert.AreEqual(manifest.ToString(), json);
+            Assert.AreEqual(manifest.ToString(), ContractManifest.CreateDefault(UInt160.Zero).ToString());
+            Assert.IsTrue(manifest.IsValid());
+        }
+
+        [TestMethod]
+        public void ParseFromJson_Features()
+        {
+            var json = @"{""groups"":[],""features"":{""storage"":true,""payable"":true},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":""*"",""trusts"":[],""safeMethods"":[]}";
+            var manifest = ContractManifest.Parse(json);
+            Assert.AreEqual(manifest.ToJson().ToString(), json);
+
+            var check = ContractManifest.CreateDefault(UInt160.Zero);
+            check.Features = ContractFeatures.HasStorage | ContractFeatures.Payable;
+            Assert.AreEqual(manifest.ToString(), check.ToString());
+        }
+
+        [TestMethod]
+        public void ParseFromJson_Permissions()
+        {
+            var json = @"{""groups"":[],""features"":{""storage"":false,""payable"":false},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":[{""contract"":""0x0000000000000000000000000000000000000000"",""methods"":[""method1"",""method2""]}],""trusts"":[],""safeMethods"":[]}";
+            var manifest = ContractManifest.Parse(json);
+            Assert.AreEqual(manifest.ToString(), json);
+
+            var check = ContractManifest.CreateDefault(UInt160.Zero);
+            check.Permissions = WildCardContainer<ContractPermission>.Create(new ContractPermission()
+            {
+                Contract = UInt160.Zero,
+                Methods = WildCardContainer<string>.Create("method1", "method2")
+            });
+            Assert.AreEqual(manifest.ToString(), check.ToString());
+        }
+
+        [TestMethod]
+        public void ParseFromJson_SafeMethods()
+        {
+            var json = @"{""groups"":[],""features"":{""storage"":false,""payable"":false},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":""*"",""trusts"":[],""safeMethods"":[""balanceOf""]}";
+            var manifest = ContractManifest.Parse(json);
+            Assert.AreEqual(manifest.ToString(), json);
+
+            var check = ContractManifest.CreateDefault(UInt160.Zero);
+            check.SafeMethods = WildCardContainer<string>.Create("balanceOf");
+            Assert.AreEqual(manifest.ToString(), check.ToString());
+        }
+
+        [TestMethod]
+        public void ParseFromJson_Trust()
+        {
+            var json = @"{""groups"":[],""features"":{""storage"":false,""payable"":false},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":""*"",""trusts"":[""0x0000000000000000000000000000000000000001""],""safeMethods"":[]}";
+            var manifest = ContractManifest.Parse(json);
+            Assert.AreEqual(manifest.ToString(), json);
+
+            var check = ContractManifest.CreateDefault(UInt160.Zero);
+            check.Trusts = WildCardContainer<UInt160>.Create(UInt160.Parse("0x0000000000000000000000000000000000000001"));
+            Assert.AreEqual(manifest.ToString(), check.ToString());
+        }
+
+        [TestMethod]
+        public void ParseFromJson_Groups()
+        {
+            var json = @"{""groups"":[{""pubKey"":""03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c"",""signature"":""41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141""}],""features"":{""storage"":false,""payable"":false},""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""entryPoint"":{""name"":""Main"",""parameters"":[{""name"":""operation"",""type"":""String""},{""name"":""args"",""type"":""Array""}],""returnType"":""Any""},""methods"":[],""events"":[]},""permissions"":""*"",""trusts"":[],""safeMethods"":[]}";
+            var manifest = ContractManifest.Parse(json);
+            Assert.AreEqual(manifest.ToString(), json);
+
+            var check = ContractManifest.CreateDefault(UInt160.Zero);
+            check.Groups = new ContractGroup[] { new ContractGroup() { PubKey = ECPoint.Parse("03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c", ECCurve.Secp256r1), Signature = "41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141".HexToBytes() } };
+            Assert.AreEqual(manifest.ToString(), check.ToString());
+        }
+    }
+}

neo.UnitTests/UT_InteropPrices.cs

@@ -1,10 +1,10 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Neo.Ledger;
 using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
 using Neo.VM;
-using System.Reflection;
 using System;
+using System.Reflection;
 
 namespace Neo.UnitTests
 {
@@ -106,7 +106,7 @@ public void ApplicationEngineVariablePrices()
             MethodInfo GetPriceForSysCall = typeof(ApplicationEngine).GetMethod("GetPriceForSysCall", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[]{}, null);
 
             // Neo.Contract.Create: f66ca56e (requires push properties on fourth position)
-            byte[] SyscallContractCreateHash00 = new byte[]{(byte)ContractPropertyState.NoProperty, 0x00, 0x00, 0x00, 0x68, 0xf6, 0x6c, 0xa5, 0x6e};
+            byte[] SyscallContractCreateHash00 = new byte[]{(byte)ContractFeatures.NoProperty, 0x00, 0x00, 0x00, 0x68, 0xf6, 0x6c, 0xa5, 0x6e};
             using ( ApplicationEngine ae = new ApplicationEngine(TriggerType.Application, null, null, 0) )
             {
                 Debugger debugger = new Debugger(ae);
@@ -131,19 +131,6 @@ public void ApplicationEngineVariablePrices()
                 GetPriceForSysCall.Invoke(ae, new object[]{}).Should().Be(500L * 100000000L / 100000); // assuming private ae.ratio = 100000
             }
 
-            // Neo.Contract.Migrate: 471b6290 (requires push properties on fourth position)
-            byte[] SyscallContractMigrateHash00 = new byte[]{(byte)ContractPropertyState.NoProperty, 0x00, 0x00, 0x00, 0x68, 0x47, 0x1b, 0x62, 0x90};
-            using ( ApplicationEngine ae = new ApplicationEngine(TriggerType.Application, null, null, 0) )
-            {
-                Debugger debugger = new Debugger(ae);
-                ae.LoadScript(SyscallContractMigrateHash00);
-                debugger.StepInto(); // push 0 - ContractPropertyState.NoProperty
-                debugger.StepInto(); // push 0
-                debugger.StepInto(); // push 0
-                debugger.StepInto(); // push 0
-                GetPriceForSysCall.Invoke(ae, new object[]{}).Should().Be(100L * 100000000L / 100000); // assuming private ae.ratio = 100000
-            }
-
             // System.Storage.Put: e63f1884 (requires push key and value)
             byte[] SyscallStoragePutHash = new byte[]{0x53, 0x53, 0x00, 0x68, 0xe6, 0x3f, 0x18, 0x84};
             using ( ApplicationEngine ae = new ApplicationEngine(TriggerType.Application, null, null, 0) )

neo/IO/Json/IJsonSerializable.cs

@@ -0,0 +1,7 @@
+namespace Neo.IO.Json
+{
+    public interface IJsonSerializable
+    {
+        JObject ToJson();
+    }
+}

neo/Ledger/ContractState.cs

@@ -1,17 +1,16 @@
 using Neo.IO;
 using Neo.IO.Json;
 using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
 using System.IO;
 
 namespace Neo.Ledger
 {
     public class ContractState : ICloneable<ContractState>, ISerializable
     {
         public byte[] Script;
-        public ContractPropertyState ContractProperties;
 
-        public bool HasStorage => ContractProperties.HasFlag(ContractPropertyState.HasStorage);
-        public bool Payable => ContractProperties.HasFlag(ContractPropertyState.Payable);
+        public ContractManifest Manifest;
 
         private UInt160 _scriptHash;
         public UInt160 ScriptHash
@@ -26,43 +25,44 @@ public UInt160 ScriptHash
             }
         }
 
-        int ISerializable.Size => Script.GetVarSize() + sizeof(ContractParameterType);
+        public bool HasStorage => Manifest.Features.HasFlag(ContractFeatures.HasStorage);
+        public bool Payable => Manifest.Features.HasFlag(ContractFeatures.Payable);
+
+        int ISerializable.Size => Script.GetVarSize() + Manifest.ToJson().ToString().GetVarSize();
 
         ContractState ICloneable<ContractState>.Clone()
         {
             return new ContractState
             {
                 Script = Script,
-                ContractProperties = ContractProperties
+                Manifest = Manifest.Clone()
             };
         }
 
         void ISerializable.Deserialize(BinaryReader reader)
         {
             Script = reader.ReadVarBytes();
-            ContractProperties = (ContractPropertyState)reader.ReadByte();
+            Manifest = reader.ReadSerializable<ContractManifest>();
         }
 
         void ICloneable<ContractState>.FromReplica(ContractState replica)
         {
             Script = replica.Script;
-            ContractProperties = replica.ContractProperties;
+            Manifest = replica.Manifest.Clone();
         }
 
         void ISerializable.Serialize(BinaryWriter writer)
         {
             writer.WriteVarBytes(Script);
-            writer.Write((byte)ContractProperties);
+            writer.Write(Manifest);
         }
 
         public JObject ToJson()
         {
-            JObject json = new JObject();
+            var json = new JObject();
             json["hash"] = ScriptHash.ToString();
             json["script"] = Script.ToHexString();
-            json["properties"] = new JObject();
-            json["properties"]["storage"] = HasStorage;
-            json["properties"]["payable"] = Payable;
+            json["manifest"] = Manifest.ToJson();
             return json;
         }
     }

neo/SmartContract/ApplicationEngine.cs

@@ -1,6 +1,7 @@
 using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
+using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native;
 using Neo.VM;
 using System;
@@ -101,13 +102,13 @@ protected virtual long GetPriceForSysCall()
                 return 100 * n;
             }
             if (method == InteropService.Neo_Contract_Create ||
-                method == InteropService.Neo_Contract_Migrate)
+                method == InteropService.Neo_Contract_Update)
             {
                 long fee = 100L;
 
-                ContractPropertyState contract_properties = (ContractPropertyState)(byte)CurrentContext.EvaluationStack.Peek(3).GetBigInteger();
+                ContractFeatures contract_properties = (ContractFeatures)(byte)CurrentContext.EvaluationStack.Peek(3).GetBigInteger();
 
-                if (contract_properties.HasFlag(ContractPropertyState.HasStorage))
+                if (contract_properties.HasFlag(ContractFeatures.HasStorage))
                 {
                     fee += 400L;
                 }

neo/SmartContract/ContractParameterType.cs

@@ -16,6 +16,7 @@ public enum ContractParameterType : byte
 
         InteropInterface = 0xf0,
 
+        Any = 0xfe,
         Void = 0xff
     }
 }

neo/SmartContract/InteropService.NEO.cs

@@ -4,6 +4,7 @@
 using Neo.Network.P2P.Payloads;
 using Neo.SmartContract.Enumerators;
 using Neo.SmartContract.Iterators;
+using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native;
 using Neo.VM;
 using Neo.VM.Types;
@@ -27,7 +28,7 @@ static partial class InteropService
         public static readonly uint Neo_Witness_GetVerificationScript = Register("Neo.Witness.GetVerificationScript", Witness_GetVerificationScript, 100);
         public static readonly uint Neo_Account_IsStandard = Register("Neo.Account.IsStandard", Account_IsStandard, 100);
         public static readonly uint Neo_Contract_Create = Register("Neo.Contract.Create", Contract_Create);
-        public static readonly uint Neo_Contract_Migrate = Register("Neo.Contract.Migrate", Contract_Migrate);
+        public static readonly uint Neo_Contract_Update = Register("Neo.Contract.Update", Contract_Update);
         public static readonly uint Neo_Contract_GetScript = Register("Neo.Contract.GetScript", Contract_GetScript, 1);
         public static readonly uint Neo_Contract_IsPayable = Register("Neo.Contract.IsPayable", Contract_IsPayable, 1);
         public static readonly uint Neo_Storage_Find = Register("Neo.Storage.Find", Storage_Find, 1);
@@ -51,12 +52,13 @@ private static bool Native_Deploy(ApplicationEngine engine)
         {
             if (engine.Trigger != TriggerType.Application) return false;
             if (engine.Snapshot.PersistingBlock.Index != 0) return false;
+
             foreach (NativeContract contract in NativeContract.Contracts)
             {
                 engine.Snapshot.Contracts.Add(contract.Hash, new ContractState
                 {
                     Script = contract.Script,
-                    ContractProperties = contract.Properties
+                    Manifest = contract.Manifest
                 });
                 contract.Initialize(engine);
             }
@@ -226,45 +228,58 @@ private static bool Contract_Create(ApplicationEngine engine)
             if (engine.Trigger != TriggerType.Application) return false;
             byte[] script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray();
             if (script.Length > 1024 * 1024) return false;
-            ContractPropertyState contract_properties = (ContractPropertyState)(byte)engine.CurrentContext.EvaluationStack.Pop().GetBigInteger();
+
+            var manifest = engine.CurrentContext.EvaluationStack.Pop().GetString();
+            if (manifest.Length > ContractManifest.MaxLength) return false;
+
             UInt160 hash = script.ToScriptHash();
             ContractState contract = engine.Snapshot.Contracts.TryGet(hash);
-            if (contract == null)
+            if (contract != null) return false;
+            contract = new ContractState
             {
-                contract = new ContractState
-                {
-                    Script = script,
-                    ContractProperties = contract_properties
-                };
-                engine.Snapshot.Contracts.Add(hash, contract);
-            }
+                Script = script,
+                Manifest = ContractManifest.Parse(manifest)
+            };
+
+            if (!contract.Manifest.IsValid()) return false;
+            if (contract.Manifest.Hash != contract.ScriptHash) return false;
+
+            engine.Snapshot.Contracts.Add(hash, contract);
             engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(contract));
             return true;
         }
 
-        private static bool Contract_Migrate(ApplicationEngine engine)
+        private static bool Contract_Update(ApplicationEngine engine)
         {
             if (engine.Trigger != TriggerType.Application) return false;
+
             byte[] script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray();
             if (script.Length > 1024 * 1024) return false;
-            ContractPropertyState contract_properties = (ContractPropertyState)(byte)engine.CurrentContext.EvaluationStack.Pop().GetBigInteger();
-            UInt160 hash = script.ToScriptHash();
-            ContractState contract = engine.Snapshot.Contracts.TryGet(hash);
-            if (contract == null)
+            var manifest = engine.CurrentContext.EvaluationStack.Pop().GetString();
+            if (manifest.Length > ContractManifest.MaxLength) return false;
+
+            var contract = engine.Snapshot.Contracts.TryGet(engine.CurrentScriptHash);
+            if (contract is null) return false;
+
+            if (script.Length > 0)
             {
+                UInt160 hash_new = script.ToScriptHash();
+                if (hash_new.Equals(engine.CurrentScriptHash)) return false;
+                if (engine.Snapshot.Contracts.TryGet(hash_new) != null) return false;
                 contract = new ContractState
                 {
                     Script = script,
-                    ContractProperties = contract_properties
+                    Manifest = contract.Manifest
                 };
-                engine.Snapshot.Contracts.Add(hash, contract);
+                contract.Manifest.Abi.Hash = hash_new;
+                engine.Snapshot.Contracts.Add(hash_new, contract);
                 if (contract.HasStorage)
                 {
                     foreach (var pair in engine.Snapshot.Storages.Find(engine.CurrentScriptHash.ToArray()).ToArray())
                     {
                         engine.Snapshot.Storages.Add(new StorageKey
                         {
-                            ScriptHash = hash,
+                            ScriptHash = hash_new,
                             Key = pair.Key.Key
                         }, new StorageItem
                         {
@@ -273,9 +288,17 @@ private static bool Contract_Migrate(ApplicationEngine engine)
                         });
                     }
                 }
+                Contract_Destroy(engine);
             }
-            engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(contract));
-            return Contract_Destroy(engine);
+            if (manifest.Length > 0)
+            {
+                contract = engine.Snapshot.Contracts.GetAndChange(contract.ScriptHash);
+                contract.Manifest = ContractManifest.Parse(manifest);
+                if (!contract.Manifest.IsValid()) return false;
+                if (contract.Manifest.Hash != contract.ScriptHash) return false;
+            }
+
+            return true;
         }
 
         private static bool Contract_GetScript(ApplicationEngine engine)