Feature manifest and permission system

neo/Ledger/ContractState.cs

@@ -8,10 +8,8 @@ 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,33 +24,36 @@ public UInt160 ScriptHash
             }
         }
 
-        int ISerializable.Size => Script.GetVarSize() + sizeof(ContractParameterType);
+        public bool HasStorage => Manifest.Features.HasFlag(ContractPropertyState.HasStorage);
+        public bool Payable => Manifest.Features.HasFlag(ContractPropertyState.Payable);
+
+        int ISerializable.Size => Script.GetVarSize() + Manifest.ToJson().GetVarSize();
 
         ContractState ICloneable<ContractState>.Clone()
         {
             return new ContractState
             {
                 Script = Script,
-                ContractProperties = ContractProperties
+                Manifest = Manifest
             };
         }
 
         void ISerializable.Deserialize(BinaryReader reader)
         {
             Script = reader.ReadVarBytes();
-            ContractProperties = (ContractPropertyState)reader.ReadByte();
+            Manifest = ContractManifest.Parse(reader.ReadVarString(ushort.MaxValue));
         }
 
         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.WriteVarString(Manifest.ToJson());
         }
 
         public JObject ToJson()
@@ -61,8 +62,8 @@ public JObject ToJson()
             json["hash"] = ScriptHash.ToString();
             json["script"] = Script.ToHexString();
             json["properties"] = new JObject();
-            json["properties"]["storage"] = HasStorage;
-            json["properties"]["payable"] = Payable;
+            json["properties"]["storage"] = Manifest.Features.HasFlag(ContractPropertyState.HasStorage);
+            json["properties"]["payable"] = Manifest.Features.HasFlag(ContractPropertyState.Payable);
             return json;
         }
     }

neo/SmartContract/ContractManifest.cs

@@ -73,5 +73,40 @@ public bool CanCall(ContractManifest manifest, string method)
 
             return Permissions == null || Permissions.IsWildcard || Permissions.Any(u => u.IsAllowed(manifest.Hash, method));
         }
+
+        /// <summary>
+        /// Parse ContractManifest from json
+        /// </summary>
+        /// <param name="json">Json</param>
+        /// <returns>Return Contract manifest</returns>
+        public static ContractManifest Parse(string json)
+        {
+            // TODO: Parse json
+
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// To json
+        /// </summary>
+        /// <returns>Return json string</returns>
+        public string ToJson()
+        {
+            // TODO: Generate json
+
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Clone
+        /// </summary>
+        /// <returns>Return a copy of this object</returns>
+        public ContractManifest Clone() => Parse(ToJson());
+
+        /// <summary>
+        /// String representation
+        /// </summary>
+        /// <returns>Return json string</returns>
+        public override string ToString() => ToJson();
     }
 }

neo/SmartContract/InteropService.NEO.cs

@@ -10,6 +10,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Text;
 using VMArray = Neo.VM.Types.Array;
 
 namespace Neo.SmartContract
@@ -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,15 +228,16 @@ 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 = Encoding.UTF8.GetString(engine.CurrentContext.EvaluationStack.Pop().GetByteArray());
             UInt160 hash = script.ToScriptHash();
             ContractState contract = engine.Snapshot.Contracts.TryGet(hash);
             if (contract == null)
             {
                 contract = new ContractState
                 {
                     Script = script,
-                    ContractProperties = contract_properties
+                    Manifest = ContractManifest.Parse(manifest)
                 };
                 engine.Snapshot.Contracts.Add(hash, contract);
             }
@@ -247,15 +250,16 @@ private static bool Contract_Migrate(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 = Encoding.UTF8.GetString(engine.CurrentContext.EvaluationStack.Pop().GetByteArray());
             UInt160 hash = script.ToScriptHash();
             ContractState contract = engine.Snapshot.Contracts.TryGet(hash);
             if (contract == null)
             {
                 contract = new ContractState
                 {
                     Script = script,
-                    ContractProperties = contract_properties
+                    Manifest = ContractManifest.Parse(manifest)
                 };
                 engine.Snapshot.Contracts.Add(hash, contract);
                 if (contract.HasStorage)

neo/SmartContract/Native/NativeContract.cs

@@ -22,7 +22,16 @@ public abstract class NativeContract
         public uint ServiceHash { get; }
         public byte[] Script { get; }
         public UInt160 Hash { get; }
-        public virtual ContractPropertyState Properties => ContractPropertyState.NoProperty;
+        public virtual ContractManifest Manifest => new ContractManifest()
+        {
+            Hash = Hash,
+            Features = ContractPropertyState.NoProperty,
+            Abi = null,
+            Groups = null,
+            Permissions = null,
+            SafeMethods = null,
+            Trusts = null
+        };
         public virtual string[] SupportedStandards { get; } = { "NEP-10" };
 
         protected NativeContract()

neo/SmartContract/Native/PolicyContract.cs

@@ -11,7 +11,16 @@ namespace Neo.SmartContract.Native
     public sealed class PolicyContract : NativeContract
     {
         public override string ServiceName => "Neo.Native.Policy";
-        public override ContractPropertyState Properties => ContractPropertyState.HasStorage;
+        public override ContractManifest Manifest
+        {
+            get
+            {
+                var manifest = base.Manifest;
+                manifest.Features = ContractPropertyState.HasStorage;
+
+                return manifest;
+            }
+        }
 
         private const byte Prefix_MaxTransactionsPerBlock = 23;
         private const byte Prefix_MaxLowPriorityTransactionsPerBlock = 34;

neo/SmartContract/Native/Tokens/Nep5Token.cs

@@ -10,7 +10,16 @@ namespace Neo.SmartContract.Native.Tokens
     public abstract class Nep5Token<TState> : NativeContract
         where TState : Nep5AccountState, new()
     {
-        public override ContractPropertyState Properties => ContractPropertyState.HasStorage;
+        public override ContractManifest Manifest
+        {
+            get
+            {
+                var manifest = base.Manifest;
+                manifest.Features = ContractPropertyState.HasStorage;
+
+                return manifest;
+            }
+        }
         public override string[] SupportedStandards { get; } = { "NEP-5", "NEP-10" };
         public abstract string Name { get; }
         public abstract string Symbol { get; }