NEP-25

src/Neo/SmartContract/Manifest/ContractAbi.cs

@@ -17,6 +17,8 @@
 using System.Linq;
 using Array = Neo.VM.Types.Array;
 
+#nullable enable
+
 namespace Neo.SmartContract.Manifest
 {
     /// <summary>
@@ -25,32 +27,51 @@ namespace Neo.SmartContract.Manifest
     /// <remarks>For more details, see NEP-14.</remarks>
     public class ContractAbi : IInteroperable
     {
-        private IReadOnlyDictionary<(string, int), ContractMethodDescriptor> methodDictionary;
+        private IReadOnlyDictionary<(string, int), ContractMethodDescriptor>? _methodDictionary;
 
         /// <summary>
         /// Gets the methods in the ABI.
         /// </summary>
-        public ContractMethodDescriptor[] Methods { get; set; }
+        public ContractMethodDescriptor[] Methods { get; set; } = [];
 
         /// <summary>
         /// Gets the events in the ABI.
         /// </summary>
-        public ContractEventDescriptor[] Events { get; set; }
+        public ContractEventDescriptor[] Events { get; set; } = [];
+
+        /// <summary>
+        /// An object with each member having a name (a string consisting of one or more identifiers joined by dots) and a value of ExtendedType object.
+        /// </summary>
+        public Dictionary<string, ExtendedType>? NamedTypes { get; set; }
 
         void IInteroperable.FromStackItem(StackItem stackItem)
         {
-            Struct @struct = (Struct)stackItem;
-            Methods = ((Array)@struct[0]).Select(p => p.ToInteroperable<ContractMethodDescriptor>()).ToArray();
-            Events = ((Array)@struct[1]).Select(p => p.ToInteroperable<ContractEventDescriptor>()).ToArray();
+            var data = (Struct)stackItem;
+            Methods = [.. ((Array)data[0]).Select(p => p.ToInteroperable<ContractMethodDescriptor>())];
+            Events = [.. ((Array)data[1]).Select(p => p.ToInteroperable<ContractEventDescriptor>())];
+
+            if (data.Count >= 3 && !data[2].IsNull)
+                NamedTypes = ((Map)data[2]).ToDictionary(p => p.Key.GetString()!, p => p.Value.ToInteroperable<ExtendedType>());
+            else
+                NamedTypes = null;
+
+            ValidateExtendedTypes();
         }
 
         public StackItem ToStackItem(IReferenceCounter referenceCounter)
         {
-            return new Struct(referenceCounter)
+            var ret = new Struct(referenceCounter)
             {
                 new Array(referenceCounter, Methods.Select(p => p.ToStackItem(referenceCounter))),
-                new Array(referenceCounter, Events.Select(p => p.ToStackItem(referenceCounter))),
+                new Array(referenceCounter, Events.Select(p => p.ToStackItem(referenceCounter)))
             };
+
+            if (NamedTypes != null)
+            {
+                ret.Add(new Map(NamedTypes.ToDictionary(p => (PrimitiveType)p.Key, p => (StackItem)p.Value.ToStackItem(referenceCounter)), referenceCounter));
+            }
+
+            return ret;
         }
 
         /// <summary>
@@ -60,15 +81,70 @@ public StackItem ToStackItem(IReferenceCounter referenceCounter)
         /// <returns>The converted ABI.</returns>
         public static ContractAbi FromJson(JObject json)
         {
+            Dictionary<string, ExtendedType>? namedTypes = null;
+            var knownNamedTypes = new HashSet<string>(StringComparer.Ordinal);
+            if (json!["namedtypes"] is JObject namedTypesJson)
+            {
+                foreach (var key in namedTypesJson.Properties.Keys)
+                {
+                    knownNamedTypes.Add(key);
+                }
+
+                namedTypes = new(namedTypesJson.Properties.Count, StringComparer.Ordinal);
+                foreach (var (name, token) in namedTypesJson.Properties)
+                {
+                    if (token is not JObject valueObject)
+                        throw new FormatException("Named type definition must be a JSON object.");
+                    namedTypes[name] = ExtendedType.FromJson(valueObject);
+                }
+            }
+
             ContractAbi abi = new()
             {
-                Methods = ((JArray)json!["methods"])?.Select(u => ContractMethodDescriptor.FromJson((JObject)u)).ToArray() ?? [],
-                Events = ((JArray)json!["events"])?.Select(u => ContractEventDescriptor.FromJson((JObject)u)).ToArray() ?? []
+                Methods = ((JArray)json!["methods"]!)?.Select(u => ContractMethodDescriptor.FromJson((JObject)u!, knownNamedTypes)).ToArray() ?? [],
+                Events = ((JArray)json!["events"]!)?.Select(u => ContractEventDescriptor.FromJson((JObject)u!, knownNamedTypes)).ToArray() ?? [],
+                NamedTypes = namedTypes
             };
-            if (abi.Methods.Length == 0) throw new FormatException("Methods in ContractAbi is empty");
+            if (abi.Methods.Length == 0) throw new FormatException("Methods in ContractAbi are empty");
+
+            abi.ValidateExtendedTypes();
             return abi;
         }
 
+        internal void ValidateExtendedTypes()
+        {
+            ISet<string> knownNamedTypes = NamedTypes != null
+                ? new HashSet<string>(NamedTypes.Keys, StringComparer.Ordinal)
+                : new HashSet<string>(StringComparer.Ordinal);
+
+            if (NamedTypes != null)
+            {
+                foreach (var (name, type) in NamedTypes)
+                {
+                    ExtendedType.EnsureValidNamedTypeIdentifier(name);
+                    type.ValidateForNamedTypeDefinition(knownNamedTypes);
+                }
+            }
+
+            foreach (var method in Methods)
+            {
+                foreach (var parameter in method.Parameters)
+                {
+                    parameter.ExtendedType?.ValidateForParameterOrReturn(parameter.Type, knownNamedTypes);
+                }
+
+                method.ExtendedReturnType?.ValidateForParameterOrReturn(method.ReturnType, knownNamedTypes);
+            }
+
+            foreach (var ev in Events)
+            {
+                foreach (var parameter in ev.Parameters)
+                {
+                    parameter.ExtendedType?.ValidateForParameterOrReturn(parameter.Type, knownNamedTypes);
+                }
+            }
+        }
+
         /// <summary>
         /// Gets the method with the specified name.
         /// </summary>
@@ -81,15 +157,17 @@ public static ContractAbi FromJson(JObject json)
         /// The method that matches the specified name and number of parameters.
         /// If <paramref name="pcount"/> is set to -1, the first method with the specified name will be returned.
         /// </returns>
-        public ContractMethodDescriptor GetMethod(string name, int pcount)
+        public ContractMethodDescriptor? GetMethod(string name, int pcount)
         {
             if (pcount < -1 || pcount > ushort.MaxValue)
                 throw new ArgumentOutOfRangeException(nameof(pcount), $"`pcount` must be between [-1, {ushort.MaxValue}]");
             if (pcount >= 0)
             {
-                methodDictionary ??= Methods.ToDictionary(p => (p.Name, p.Parameters.Length));
-                methodDictionary.TryGetValue((name, pcount), out var method);
-                return method;
+                _methodDictionary ??= Methods.ToDictionary(p => (p.Name, p.Parameters.Length));
+                if (_methodDictionary.TryGetValue((name, pcount), out var method))
+                    return method;
+
+                return null;
             }
             else
             {
@@ -103,11 +181,20 @@ public ContractMethodDescriptor GetMethod(string name, int pcount)
         /// <returns>The ABI represented by a JSON object.</returns>
         public JObject ToJson()
         {
-            return new JObject()
+            var ret = new JObject()
             {
-                ["methods"] = new JArray(Methods.Select(u => u.ToJson()).ToArray()),
-                ["events"] = new JArray(Events.Select(u => u.ToJson()).ToArray())
+                ["methods"] = new JArray([.. Methods.Select(u => u.ToJson())]),
+                ["events"] = new JArray([.. Events.Select(u => u.ToJson())])
             };
+
+            if (NamedTypes != null)
+            {
+                ret["namedtypes"] = new JObject(NamedTypes.ToDictionary(u => u.Key, u => (JToken?)u.Value.ToJson()));
+            }
+
+            return ret;
         }
     }
 }
+
+#nullable disable

src/Neo/SmartContract/Manifest/ContractEventDescriptor.cs

@@ -13,6 +13,7 @@
 using Neo.VM;
 using Neo.VM.Types;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Array = Neo.VM.Types.Array;
@@ -54,15 +55,16 @@ public virtual StackItem ToStackItem(IReferenceCounter referenceCounter)
         /// Converts the event from a JSON object.
         /// </summary>
         /// <param name="json">The event represented by a JSON object.</param>
+        /// <param name="knownNamedTypes">Set of named type identifiers declared in the manifest, if any.</param>
         /// <returns>The converted event.</returns>
-        public static ContractEventDescriptor FromJson(JObject json)
+        public static ContractEventDescriptor FromJson(JObject json, ISet<string> knownNamedTypes = null)
         {
             ContractEventDescriptor descriptor = new()
             {
                 Name = json["name"].GetString(),
-                Parameters = ((JArray)json["parameters"]).Select(u => ContractParameterDefinition.FromJson((JObject)u)).ToArray(),
+                Parameters = ((JArray)json["parameters"]).Select(u => ContractParameterDefinition.FromJson((JObject)u, knownNamedTypes)).ToArray(),
             };
-            if (string.IsNullOrEmpty(descriptor.Name)) throw new FormatException("Name in ContractEventDescriptor is empty");
+            if (string.IsNullOrEmpty(descriptor.Name)) throw new FormatException("Name in ContractEventDescriptor are empty");
             _ = descriptor.Parameters.ToDictionary(p => p.Name);
             return descriptor;
         }

src/Neo/SmartContract/Manifest/ContractMethodDescriptor.cs

@@ -13,6 +13,7 @@
 using Neo.VM;
 using Neo.VM.Types;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 
@@ -28,6 +29,11 @@ public class ContractMethodDescriptor : ContractEventDescriptor, IEquatable<Cont
         /// </summary>
         public ContractParameterType ReturnType { get; set; }
 
+        /// <summary>
+        /// NEP-25 extended return type
+        /// </summary>
+        public ExtendedType ExtendedReturnType { get; set; }
+
         /// <summary>
         /// The position of the method in the contract script.
         /// </summary>
@@ -42,46 +48,63 @@ public class ContractMethodDescriptor : ContractEventDescriptor, IEquatable<Cont
         public override void FromStackItem(StackItem stackItem)
         {
             base.FromStackItem(stackItem);
-            Struct @struct = (Struct)stackItem;
-            ReturnType = (ContractParameterType)(byte)@struct[2].GetInteger();
-            Offset = (int)@struct[3].GetInteger();
-            Safe = @struct[4].GetBoolean();
+            var item = (Struct)stackItem;
+            ReturnType = (ContractParameterType)(byte)item[2].GetInteger();
+            Offset = (int)item[3].GetInteger();
+            Safe = item[4].GetBoolean();
+
+            if (item.Count >= 6)
+            {
+                ExtendedReturnType = new ExtendedType();
+                ExtendedReturnType.FromStackItem(item[5]);
+                ExtendedReturnType.ValidateForParameterOrReturn(ReturnType, null);
+            }
+            else
+            {
+                ExtendedReturnType = null;
+            }
         }
 
         public override StackItem ToStackItem(IReferenceCounter referenceCounter)
         {
-            Struct @struct = (Struct)base.ToStackItem(referenceCounter);
-            @struct.Add((byte)ReturnType);
-            @struct.Add(Offset);
-            @struct.Add(Safe);
-            return @struct;
+            var item = (Struct)base.ToStackItem(referenceCounter);
+            item.Add((byte)ReturnType);
+            item.Add(Offset);
+            item.Add(Safe);
+            if (ExtendedReturnType != null)
+            {
+                item.Add(ExtendedReturnType.ToStackItem(referenceCounter));
+            }
+            return item;
         }
 
         /// <summary>
         /// Converts the method from a JSON object.
         /// </summary>
         /// <param name="json">The method represented by a JSON object.</param>
+        /// <param name="knownNamedTypes">Set of named type identifiers declared in the manifest, if any.</param>
         /// <returns>The converted method.</returns>
-        public new static ContractMethodDescriptor FromJson(JObject json)
+        public new static ContractMethodDescriptor FromJson(JObject json, ISet<string> knownNamedTypes = null)
         {
             ContractMethodDescriptor descriptor = new()
             {
                 Name = json["name"].GetString(),
-                Parameters = ((JArray)json["parameters"]).Select(u => ContractParameterDefinition.FromJson((JObject)u)).ToArray(),
+                Parameters = ((JArray)json["parameters"]).Select(u => ContractParameterDefinition.FromJson((JObject)u, knownNamedTypes)).ToArray(),
                 ReturnType = Enum.Parse<ContractParameterType>(json["returntype"].GetString()),
                 Offset = json["offset"].GetInt32(),
-                Safe = json["safe"].GetBoolean()
+                Safe = json["safe"].GetBoolean(),
+                ExtendedReturnType = json["extendedreturntype"] != null ? ExtendedType.FromJson((JObject)json["extendedreturntype"]) : null
             };
 
             if (string.IsNullOrEmpty(descriptor.Name))
-                throw new FormatException("Name in ContractMethodDescriptor is empty");
+                throw new FormatException("Name in ContractMethodDescriptor are empty");
 
             _ = descriptor.Parameters.ToDictionary(p => p.Name);
-
             if (!Enum.IsDefined(typeof(ContractParameterType), descriptor.ReturnType))
-                throw new FormatException($"ReturnType({descriptor.ReturnType}) in ContractMethodDescriptor is not valid");
+                throw new FormatException($"ReturnType({descriptor.ReturnType}) in ContractMethodDescriptor are not valid");
             if (descriptor.Offset < 0)
-                throw new FormatException($"Offset({descriptor.Offset}) in ContractMethodDescriptor is not valid");
+                throw new FormatException($"Offset({descriptor.Offset}) in ContractMethodDescriptor are not valid");
+            descriptor.ExtendedReturnType?.ValidateForParameterOrReturn(descriptor.ReturnType, knownNamedTypes);
             return descriptor;
         }
 
@@ -95,6 +118,10 @@ public override JObject ToJson()
             json["returntype"] = ReturnType.ToString();
             json["offset"] = Offset;
             json["safe"] = Safe;
+            if (ExtendedReturnType != null)
+            {
+                json["extendedreturntype"] = ExtendedReturnType.ToJson();
+            }
             return json;
         }
 
@@ -106,7 +133,8 @@ public bool Equals(ContractMethodDescriptor other)
                 base.Equals(other) && // Already check null
                 ReturnType == other.ReturnType
                 && Offset == other.Offset
-                && Safe == other.Safe;
+                && Safe == other.Safe
+                && Equals(ExtendedReturnType, other.ExtendedReturnType);
         }
 
         public override bool Equals(object other)
@@ -119,7 +147,7 @@ public override bool Equals(object other)
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(ReturnType, Offset, Safe, base.GetHashCode());
+            return HashCode.Combine(ReturnType, Offset, Safe, ExtendedReturnType?.GetHashCode() ?? -1, base.GetHashCode());
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]