Feature manifest and permission system

neo/SmartContract/ContractAbi.cs

@@ -0,0 +1,28 @@
+namespace Neo.SmartContract
+{
+    /// <summary>
+    /// For technical details of ABI, please refer to NEP-3: NeoContract ABI. (https://github.com/neo-project/proposals/blob/master/nep-3.mediawiki)
+    /// </summary>
+    public class ContractAbi
+    {
+        /// <summary>
+        /// Hash is the script hash of the contract. It is encoded as a hexadecimal string in big-endian.
+        /// </summary>
+        public UInt160 Hash { get; set; }
+
+        /// <summary>
+        /// Entrypoint is a Method object which describe the details of the entrypoint of the contract.
+        /// </summary>
+        public ContractMethodWithReturnDefinition EntryPoint { get; set; }
+
+        /// <summary>
+        /// Methods is an array of Method objects which describe the details of each method in the contract.
+        /// </summary>
+        public ContractMethodWithReturnDefinition[] Methods { get; set; }
+
+        /// <summary>
+        /// Events is an array of Event objects which describe the details of each event in the contract.
+        /// </summary>
+        public ContractMethodDefinition[] Events { get; set; }
+    }
+}

neo/SmartContract/ContractManifest.cs

@@ -0,0 +1,77 @@
+using Neo.Ledger;
+using System;
+using System.Linq;
+
+namespace Neo.SmartContract
+{
+    /// <summary>
+    /// When a smart contract is deployed, it must explicitly declare the features and permissions it will use.
+    /// When it is running, it will be limited by its declared list of features and permissions, and cannot make any behavior beyond the scope of the list.
+    /// </summary>
+    public class ContractManifest
+    {
+        /// <summary>
+        /// Contract hash
+        /// </summary>
+        public UInt160 Hash { get; set; }
+
+        /// <summary>
+        /// A group represents a set of mutually trusted contracts. A contract will trust and allow any contract in the same group to invoke it, and the user interface will not give any warnings.
+        /// The group field can be null.
+        /// </summary>
+        public ContractManifestGroup[] Groups { get; set; }
+
+        /// <summary>
+        /// The features field describes what features are available for the contract.
+        /// </summary>
+        public ContractPropertyState Features { get; set; }
+
+        /// <summary>
+        /// For technical details of ABI, please refer to NEP-3: NeoContract ABI. (https://github.com/neo-project/proposals/blob/master/nep-3.mediawiki)
+        /// </summary>
+        public ContractAbi Abi { get; set; }
+
+        /// <summary>
+        /// The permissions field is an array containing a set of Permission objects. It describes which contracts may be invoked and which methods are called.
+        /// </summary>
+        public WillCardContainer<ContractPermission> Permissions { get; set; }
+
+        /// <summary>
+        /// The trusts field is an array containing a set of contract hashes or group public keys. It can also be assigned with a wildcard *. If it is a wildcard *, then it means that it trusts any contract.
+        /// If a contract is trusted, the user interface will not give any warnings when called by the contract.
+        /// </summary>
+        public WillCardContainer<UInt160> Trusts { get; set; }
+
+        /// <summary>
+        /// The safemethods field is an array containing a set of method names. It can also be assigned with a wildcard *. If it is a wildcard *, then it means that all methods of the contract are safe.
+        /// If a method is marked as safe, the user interface will not give any warnings when it is called by any other contract.
+        /// </summary>
+        public WillCardContainer<string> SafeMethods { get; set; }
+
+        /// <summary>
+        /// Return true if is allowed
+        /// </summary>
+        /// <param name="manifest">Manifest</param>
+        /// <param name="method">Method</param>
+        /// <returns>Return true or false</returns>
+        public bool CanCall(ContractManifest manifest, string method)
+        {
+            if (Groups != null && manifest.Groups != null && Groups.Any(a => manifest.Groups.Any(b => a.PubKey.Equals(b.PubKey))))
+            {
+                // Same group
+
+                return true;
+            }
+
+            if (manifest.Trusts != null && !manifest.Trusts.IsWildcard && !manifest.Trusts.Contains(Hash))
+            {
+                // null == * wildcard
+                // You don't have rights in the contract
+
+                return false;
+            }
+
+            return Permissions == null || Permissions.IsWildcard || Permissions.Any(u => u.IsAllowed(manifest.Hash, method));
+        }
+    }
+}

neo/SmartContract/ContractManifestGroup.cs

@@ -0,0 +1,32 @@
+using Neo.Cryptography;
+
+namespace Neo.SmartContract
+{
+    /// <summary>
+    /// A group represents a set of mutually trusted contracts. A contract will trust and allow any contract in the same group to invoke it, and the user interface will not give any warnings.
+    /// The group field can be null.
+    /// A group is identified by a public key and must be accompanied by a signature for the contract hash to prove that the contract is indeed included in the group.
+    /// </summary>
+    public class ContractManifestGroup
+    {
+        /// <summary>
+        /// Pubkey represents the public key of the group.
+        /// </summary>
+        public UInt160 PubKey { get; set; }
+
+        /// <summary>
+        /// Signature is the signature of the contract hash.
+        /// </summary>
+        public byte[] Signature { get; set; }
+
+        /// <summary>
+        /// Return true if the signature is valid
+        /// </summary>
+        /// <param name="contractHash">Contract Hash</param>
+        /// <returns>Return true or false</returns>
+        public bool IsValid(UInt160 contractHash)
+        {
+            return Crypto.Default.VerifySignature(contractHash.ToArray(), Signature, PubKey.ToArray());
+        }
+    }
+}

neo/SmartContract/ContractMethodDefinition.cs

@@ -0,0 +1,15 @@
+namespace Neo.SmartContract
+{
+    public class ContractMethodDefinition
+    {
+        /// <summary>
+        /// Name is the name of the method, which can be any valid identifier.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Parameters is an array of Parameter objects which describe the details of each parameter in the method.
+        /// </summary>
+        public ContractParameterDefinition[] Parameters { get; set; }
+    }
+}

neo/SmartContract/ContractMethodWithReturnDefinition.cs

@@ -0,0 +1,11 @@
+namespace Neo.SmartContract
+{
+    public class ContractMethodWithReturnDefinition : ContractMethodDefinition
+    {
+        /// <summary>
+        /// Returntype indicates the return type of the method. It can be one of the following values: 
+        ///     Signature, Boolean, Integer, Hash160, Hash256, ByteArray, PublicKey, String, Array, InteropInterface, Void.
+        /// </summary>
+        public ContractParameterType ReturnType { get; set; }
+    }
+}

neo/SmartContract/ContractParameterDefinition.cs

@@ -0,0 +1,16 @@
+namespace Neo.SmartContract
+{
+    public class ContractParameterDefinition
+    {
+        /// <summary>
+        /// Name is the name of the parameter, which can be any valid identifier.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Type indicates the type of the parameter. It can be one of the following values: 
+        ///     Signature, Boolean, Integer, Hash160, Hash256, ByteArray, PublicKey, String, Array, InteropInterface.
+        /// </summary>
+        public ContractParameterType Type { get; set; }
+    }
+}

neo/SmartContract/ContractPermission.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Linq;
+
+namespace Neo.SmartContract
+{
+    /// <summary>
+    /// The permissions field is an array containing a set of Permission objects. It describes which contracts may be invoked and which methods are called.
+    /// </summary>
+    public class ContractPermission
+    {
+        /// <summary>
+        /// The contract field indicates the contract to be invoked. It can be a hash of a contract, a public key of a group, or a wildcard *.
+        /// If it specifies a hash of a contract, then the contract will be invoked; If it specifies a public key of a group, then any contract in this group will be invoked; If it specifies a wildcard*, then any contract will be invoked.
+        /// </summary>
+        public UInt160 Contract { get; set; }
+
+        /// <summary>
+        /// The methods field is an array containing a set of methods to be called. It can also be assigned with a wildcard *. If it is a wildcard *, then it means that any method can be called.
+        /// If a contract invokes a contract or method that is not declared in the manifest at runtime, the invocation will fail.
+        /// </summary>
+        public WillCardContainer<string> Methods { get; set; }
+
+        /// <summary>
+        /// Return true if is allowed
+        /// </summary>
+        /// <param name="contractHash">Contract hash</param>
+        /// <param name="method">Method</param>
+        /// <returns>Return true or false</returns>
+        public bool IsAllowed(UInt160 contractHash, string method)
+        {
+            if (!Contract.Equals(contractHash))
+            {
+                // 0x00 = * wildcard
+
+                if (Contract != UInt160.Zero) return false;
+            }
+
+            return Methods == null || Methods.IsWildcard || Methods.Contains(method);
+        }
+    }
+}

neo/SmartContract/WillCardContainer.cs

@@ -0,0 +1,48 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Neo.SmartContract
+{
+    public class WillCardContainer<T> : IReadOnlyList<T>
+    {
+        private readonly T[] _data;
+
+        public T this[int index] => _data[index];
+
+        /// <summary>
+        /// Number of items
+        /// </summary>
+        public int Count => _data?.Length ?? 0;
+
+        /// <summary>
+        /// Is will card?
+        /// </summary>
+        public bool IsWildcard => _data == null;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="data">Data</param>
+        public WillCardContainer(T[] data)
+        {
+            _data = data;
+        }
+
+        /// <summary>
+        /// Create a new WillCardContainer
+        /// </summary>
+        /// <param name="data">Data</param>
+        /// <returns>WillCardContainer</returns>
+        public static WillCardContainer<T> Create(params T[] data) => new WillCardContainer<T>(data);
+
+        /// <summary>
+        /// Create a will card
+        /// </summary>
+        /// <returns>WillCardContainer</returns>
+        public static WillCardContainer<T> CreateWildcard() => new WillCardContainer<T>(null);
+
+        public IEnumerator<T> GetEnumerator() => ((IReadOnlyList<T>)_data).GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}