11747354015

Committed 08 Nov 2024 06:14PM UTC coverage: 74.055%. Remained the same

Build # 11747354015

Build Type

Pull #1236

github

Committed by

web-flow

Commit Message

Merge b09cdc7ae into e5c8d243b

Pull Request Pull Request #1236: Fix `Dissasembler`

Run Details

4825 of 7080 branches covered (68.15%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 1 file covered. (100.0%)

3 existing lines in 1 file now uncovered.

12909 of 16867 relevant lines covered (76.53%)

17630.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.83

/src/Neo.SmartContract.Testing/Extensions/ArtifactExtensions.cs

using Neo.Disassembler.CSharp;
using Neo.IO;
using Neo.Json;
using Neo.SmartContract.Manifest;
using Neo.SmartContract.Testing.TestingStandards;
using Neo.VM;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Neo.SmartContract.Testing.Extensions
{
    public static class ArtifactExtensions
    {
        static readonly string[] _protectedWords =
        [
            "abstract",
            "as",
            "base",
            "bool",
            "break",
            "byte",
            "case",
            "catch",
            "char",
            "checked",
            "class",
            "const",
            "continue",
            "decimal",
            "default",
            "delegate",
            "do",
            "double",
            "else",
            "enum",
            "event",
            "explicit",
            "extern",
            "false",
            "finally",
            "fixed",
            "float",
            "for",
            "foreach",
            "goto",
            "if",
            "implicit",
            "in",
            "int",
            "interface",
            "internal",
            "is",
            "lock",
            "long",
            "namespace",
            "new",
            "null",
            "object",
            "operator",
            "out",
            "override",
            "params",
            "private",
            "protected",
            "public",
            "readonly",
            "ref",
            "return",
            "sbyte",
            "sealed",
            "short",
            "sizeof",
            "stackalloc",
            "static",
            "string",
            "struct",
            "switch",
            "this",
            "throw",
            "true",
            "try",
            "typeof",
            "uint",
            "ulong",
            "unchecked",
            "unsafe",
            "ushort",
            "using",
            "virtual",
            "void",
            "volatile",
            "while"
        ];

        /// <summary>
        /// Get source code from contract Manifest
        /// </summary>
        /// <param name="manifest">Manifest</param>
        /// <param name="name">Class name, by default is manifest.Name</param>
        /// <param name="nef">Nef file</param>
        /// <param name="generateProperties">Generate properties</param>
        /// <returns>Source</returns>
        public static string GetArtifactsSource(this ContractManifest manifest, string? name = null, NefFile? nef = null, bool generateProperties = true, JToken? debugInfo = null)
        {
            name ??= manifest.Name;
            var builder = new StringBuilder();
            using var sourceCode = new StringWriter(builder)
            {
                NewLine = "\n"
            };

            var inheritance = new List<Type>
            {
                typeof(SmartContract)
            };

            if (manifest.IsNep17()) inheritance.Add(typeof(INep17Standard));
            if (manifest.IsOwnable()) inheritance.Add(typeof(IOwnable));
            if (manifest.IsVerificable()) inheritance.Add(typeof(IVerificable));

            sourceCode.WriteLine("using Neo.Cryptography.ECC;");
            sourceCode.WriteLine("using System;");
            sourceCode.WriteLine("using System.Collections.Generic;");
            sourceCode.WriteLine("using System.ComponentModel;");
            sourceCode.WriteLine("using System.Numerics;");
            sourceCode.WriteLine("");
            sourceCode.WriteLine("namespace Neo.SmartContract.Testing;");
            sourceCode.WriteLine("");
            sourceCode.WriteLine($"public abstract class {name}({typeof(SmartContractInitialize).FullName} initialize) : " + FormatInheritance(inheritance, "initialize") + ", IContractInfo");
            sourceCode.WriteLine("{");

            // Write compiled data

            sourceCode.WriteLine("    #region Compiled data");
            sourceCode.WriteLine();

            var value = manifest.ToJson().ToString(false).Replace("\"", "\"\"");
            sourceCode.WriteLine($"    public static {typeof(ContractManifest).FullName} Manifest => {typeof(ContractManifest).FullName}.Parse(@\"{value}\");");
            sourceCode.WriteLine();

            if (nef is not null)
            {
                value = Convert.ToBase64String(nef.ToArray()).Replace("\"", "\"\"");

                var optimization = manifest.Extra?["nef"]?["optimization"]?.ToString();

                if (optimization != null)
                {
                    sourceCode.WriteLine($"    /// <summary>");
                    sourceCode.WriteLine($"    /// Optimization: {optimization}");
                    sourceCode.WriteLine($"    /// </summary>");
                }
                sourceCode.WriteLine($"    public static {typeof(NefFile).FullName} Nef => Neo.IO.Helper.AsSerializable<{typeof(NefFile).FullName}>(Convert.FromBase64String(@\"{value}\"));");
                sourceCode.WriteLine();
            }

            sourceCode.WriteLine("    #endregion");
            sourceCode.WriteLine();

            // Crete events

            if (manifest.Abi.Events.Any())
            {
                sourceCode.WriteLine("    #region Events");
                sourceCode.WriteLine();

                foreach (var ev in manifest.Abi.Events.OrderBy(u => u.Name))
                {
                    sourceCode.Write(CreateSourceEventFromManifest(ev, inheritance));
                    sourceCode.WriteLine();
                }

                sourceCode.WriteLine("    #endregion");
                sourceCode.WriteLine();
            }

            // Create methods

            var methods = manifest.Abi.Methods;

            if (generateProperties)
            {
                (methods, var properties) = ProcessAbiMethods(manifest.Abi.Methods);

                if (properties.Any())
                {
                    sourceCode.WriteLine("    #region Properties");
                    sourceCode.WriteLine();

                    foreach (var property in properties.OrderBy(u => u.getter.Name))
                    {
                        sourceCode.Write(CreateSourcePropertyFromManifest(property.getter, property.setter));
                        sourceCode.WriteLine();
                    }

                    sourceCode.WriteLine("    #endregion");
                    sourceCode.WriteLine();
                }
            }

            if (methods.Any(u => u.Safe))
            {
                sourceCode.WriteLine("    #region Safe methods");
                sourceCode.WriteLine();

                foreach (var method in methods.Where(u => u.Safe).OrderBy(u => u.Name))
                {
                    // This method can't be called, so avoid them

                    if (method.Name.StartsWith("_")) continue;

                    sourceCode.Write(CreateSourceMethodFromManifest(method, nef, debugInfo));
                    sourceCode.WriteLine();
                }

                sourceCode.WriteLine("    #endregion");
                sourceCode.WriteLine();
            }

            if (methods.Any(u => !u.Safe))
            {
                sourceCode.WriteLine("    #region Unsafe methods");
                sourceCode.WriteLine();

                foreach (var method in methods.Where(u => !u.Safe).OrderBy(u => u.Name))
                {
                    // This method can't be called, so avoid them

                    if (method.Name.StartsWith("_")) continue;

                    sourceCode.Write(CreateSourceMethodFromManifest(method, nef, debugInfo));
                    sourceCode.WriteLine();
                }
                sourceCode.WriteLine("    #endregion");
            }

            sourceCode.WriteLine("}");

            return sourceCode.ToString();
        }

        private static (ContractMethodDescriptor[] methods, (ContractMethodDescriptor getter, ContractMethodDescriptor? setter)[] properties)
            ProcessAbiMethods(ContractMethodDescriptor[] methods)
        {
            HashSet<string> propertyNames = new();
            List<ContractMethodDescriptor> methodList = new(methods);
            List<(ContractMethodDescriptor, ContractMethodDescriptor?)> properties = new();

            // Detect and extract properties, first find Safe && 0 args && return != void

            foreach (ContractMethodDescriptor getter in methods.Where(u => u.Safe && u.Parameters.Length == 0 && u.ReturnType != ContractParameterType.Void).ToArray())
            {
                // Find setter: setXXX && one arg && not safe && parameter = getter.return && return == void

                var setter = getter.Name.StartsWith("get") ? // Only find setter if start with get
                    methodList.FirstOrDefault(
                    u =>
                        u.Name == "set" + getter.Name[3..] &&
                        !u.Safe &&
                        u.Parameters.Length == 1 &&
                        u.Parameters[0].Type == getter.ReturnType &&
                        u.ReturnType == ContractParameterType.Void
                        ) : null;

                // Avoid property repetition

                var propertyName = GetPropertyName(getter);
                if (!propertyNames.Add(propertyName)) continue;

                // Add property and remove method

                properties.Add((getter, setter));
                methodList.Remove(getter);

                if (setter != null)
                {
                    methodList.Remove(setter);
                }
            }

            return (methodList.ToArray(), properties.ToArray());
        }

        private static string GetPropertyName(ContractMethodDescriptor getter)
        {
            return TongleLowercase(EscapeName(getter.Name.StartsWith("get") ? getter.Name[3..] : getter.Name));
        }

        /// <summary>
        /// Create source code from event
        /// </summary>
        /// <param name="ev">Event</param>
        /// <param name="inheritance">Inheritance</param>
        /// <returns>Source</returns>
        private static string CreateSourceEventFromManifest(ContractEventDescriptor ev, IList<Type> inheritance)
        {
            var builder = new StringBuilder();
            using var sourceCode = new StringWriter(builder)
            {
                NewLine = "\n"
            };

            switch (ev.Name)
            {
                case "Transfer":
                    {
                        if (inheritance.Contains(typeof(INep17Standard)) && ev.Parameters.Length == 3 &&
                            ev.Parameters[0].Type == ContractParameterType.Hash160 &&
                            ev.Parameters[1].Type == ContractParameterType.Hash160 &&
                            ev.Parameters[2].Type == ContractParameterType.Integer)
                        {
                            sourceCode.WriteLine($"    [DisplayName(\"{ev.Name}\")]");
                            sourceCode.WriteLine($"    public event {typeof(INep17Standard).FullName}.delTransfer? OnTransfer;");
                            return builder.ToString();
                        }

                        break;
                    }
                case "SetOwner":
                    {
                        if (inheritance.Contains(typeof(IOwnable)) && ev.Parameters.Length == 2 &&
                            ev.Parameters[0].Type == ContractParameterType.Hash160 &&
                            ev.Parameters[1].Type == ContractParameterType.Hash160)
                        {
                            sourceCode.WriteLine($"    [DisplayName(\"{ev.Name}\")]");
                            sourceCode.WriteLine($"    public event {typeof(IOwnable).FullName}.delSetOwner? OnSetOwner;");
                            return builder.ToString();
                        }

                        break;
                    }
            }

            // Add On prefix

            var evName = TongleLowercase(EscapeName(ev.Name));
            if (!evName.StartsWith("On")) evName = "On" + evName;

            // Compose delegate

            sourceCode.Write($"    public delegate void del{ev.Name}(");

            var isFirst = true;
            foreach (var arg in ev.Parameters)
            {
                if (!isFirst) sourceCode.Write(", ");
                else isFirst = false;

                sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)}");
            }

            sourceCode.WriteLine(");");
            sourceCode.WriteLine();

            // Compose event

            if (ev.Name != evName)
            {
                sourceCode.WriteLine($"    [DisplayName(\"{ev.Name}\")]");
            }
            sourceCode.WriteLine($"    public event del{ev.Name}? {evName};");

            return builder.ToString();
        }

        /// <summary>
        /// Create source code from manifest property
        /// </summary>
        /// <param name="getter">Getter</param>
        /// <param name="setter">Setter</param>
        /// <returns>Source</returns>
        private static string CreateSourcePropertyFromManifest(ContractMethodDescriptor getter, ContractMethodDescriptor? setter)
        {
            var propertyName = GetPropertyName(getter);
            var getset = setter is not null ? $"{{ [DisplayName(\"{getter.Name}\")] get; [DisplayName(\"{setter.Name}\")] set; }}" : $"{{ [DisplayName(\"{getter.Name}\")] get; }}";

            var builder = new StringBuilder();
            using var sourceCode = new StringWriter(builder)
            {
                NewLine = "\n"
            };

            sourceCode.WriteLine($"    /// <summary>");
            sourceCode.WriteLine($"    /// {(getter.Safe ? "Safe property" : "Unsafe property")}");
            sourceCode.WriteLine($"    /// </summary>");
            sourceCode.WriteLine($"    public abstract {TypeToSource(getter.ReturnType)} {propertyName} {getset}");

            return builder.ToString();
        }

        /// <summary>
        /// Create source code from manifest method
        /// </summary>
        /// <param name="method">Contract method</param>
        /// <param name="nefFile">Nef File</param>
        /// <param name="debugInfo">Debug info</param>
        /// <returns>Source</returns>
        private static string CreateSourceMethodFromManifest(ContractMethodDescriptor method, NefFile? nefFile = null, JToken? debugInfo = null)
        {
            var methodName = TongleLowercase(EscapeName(method.Name));

            var builder = new StringBuilder();
            using var sourceCode = new StringWriter(builder)
            {
                NewLine = "\n"
            };

            sourceCode.WriteLine($"    /// <summary>");
            sourceCode.WriteLine($"    /// {(method.Safe ? "Safe method" : "Unsafe method")}");
            sourceCode.WriteLine($"    /// </summary>");

            // Add the opcodes
            if (debugInfo != null && nefFile != null)
            {
                var instructions = Disassembler.CSharp.Disassembler.ConvertMethodToInstructions(nefFile, debugInfo, method.Name, method.Parameters.Length);
                if (instructions is not null && instructions.Count > 0)
                {
                    Script script = nefFile.Script;
                    (var start, var end, _) = Disassembler.CSharp.Disassembler.GetMethodStartEndAddress(method.Name, method.Parameters.Length, debugInfo);
                    var actualEnd = end + script.GetInstruction(end).Size;
                    var scripts = nefFile.Script[start..actualEnd].ToArray();

                    var maxAddressLength = instructions.Max(instruction => instruction.address.ToString("X").Length);
                    var addressFormat = $"X{(maxAddressLength + 1) / 2 * 2}";

                    sourceCode.WriteLine("    /// <remarks>");
                    sourceCode.WriteLine($"    /// Script: {Convert.ToBase64String(scripts)}");
                    foreach (var instruction in instructions)
                    {
                        sourceCode.WriteLine($"    /// {instruction.address.ToString(addressFormat)} : {instruction.instruction.InstructionToString(true)}");
                    }
                    sourceCode.WriteLine("    /// </remarks>");
                }
            }

            if (method.Name != methodName)
            {
                sourceCode.WriteLine($"    [DisplayName(\"{method.Name}\")]");
            }
            sourceCode.Write($"    public abstract {TypeToSource(method.ReturnType)} {methodName}(");

            var isFirst = true;
            for (int x = 0; x < method.Parameters.Length; x++)
            {
                if (!isFirst) sourceCode.Write(", ");
                else isFirst = false;

                var isLast = x == method.Parameters.Length - 1;
                var arg = method.Parameters[x];

                if (isLast && arg.Type == ContractParameterType.Any)
                {
                    // it will be `object X`, we can add a default value

                    sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)} = null");
                }
                else
                {
                    sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)}");
                }
            }

            sourceCode.WriteLine(");");

            return builder.ToString();
        }

        private static string TongleLowercase(string value)
        {
            if (value.Length == 0)
            {
                return value;
            }

            if (char.IsLower(value[0]))
            {
                return value[0].ToString().ToUpperInvariant() + value[1..];
            }

            return value;
        }

        /// <summary>
        /// Escape name
        /// </summary>
        /// <param name="name">Name</param>
        /// <returns>Escaped name</returns>
        private static string EscapeName(string name)
        {
            if (_protectedWords.Contains(name))
                return "@" + name;

            return name;
        }

        /// <summary>
        /// Type to source
        /// </summary>
        /// <param name="type">Type</param>
        /// <returns>c# type</returns>
        private static string TypeToSource(ContractParameterType type)
        {
            return type switch
            {
                ContractParameterType.Boolean => "bool?",
                ContractParameterType.Integer => "BigInteger?",
                ContractParameterType.String => "string?",
                ContractParameterType.Hash160 => "UInt160?",
                ContractParameterType.Hash256 => "UInt256?",
                ContractParameterType.PublicKey => "ECPoint?",
                ContractParameterType.ByteArray => "byte[]?",
                ContractParameterType.Signature => "byte[]?",
                ContractParameterType.Array => "IList<object>?",
                ContractParameterType.Map => "IDictionary<object, object>?",
                ContractParameterType.Void => "void",
                _ => "object?",
            };
        }

        private static string FormatInheritance(List<Type> inheritance, string initializeParam)
        {
            var formattedInheritance = inheritance.Select(type => (type == typeof(SmartContract)
                    ? $"{type.FullName}({initializeParam})"
                    : type.FullName)!)
                .ToList();
            return string.Join(", ", formattedInheritance);
        }
    }
}

1	using Neo.Disassembler.CSharp;
2	using Neo.IO;
3	using Neo.Json;
4	using Neo.SmartContract.Manifest;
5	using Neo.SmartContract.Testing.TestingStandards;
6	using Neo.VM;
7	using System;
8	using System.Collections.Generic;
9	using System.IO;
10	using System.Linq;
11	using System.Text;
12
13	namespace Neo.SmartContract.Testing.Extensions
14	{
15	public static class ArtifactExtensions
16	{
17	static readonly string[] _protectedWords =	4✔
18	[	4✔
19	"abstract",	4✔
20	"as",	4✔
21	"base",	4✔
22	"bool",	4✔
23	"break",	4✔
24	"byte",	4✔
25	"case",	4✔
26	"catch",	4✔
27	"char",	4✔
28	"checked",	4✔
29	"class",	4✔
30	"const",	4✔
31	"continue",	4✔
32	"decimal",	4✔
33	"default",	4✔
34	"delegate",	4✔
35	"do",	4✔
36	"double",	4✔
37	"else",	4✔
38	"enum",	4✔
39	"event",	4✔
40	"explicit",	4✔
41	"extern",	4✔
42	"false",	4✔
43	"finally",	4✔
44	"fixed",	4✔
45	"float",	4✔
46	"for",	4✔
47	"foreach",	4✔
48	"goto",	4✔
49	"if",	4✔
50	"implicit",	4✔
51	"in",	4✔
52	"int",	4✔
53	"interface",	4✔
54	"internal",	4✔
55	"is",	4✔
56	"lock",	4✔
57	"long",	4✔
58	"namespace",	4✔
59	"new",	4✔
60	"null",	4✔
61	"object",	4✔
62	"operator",	4✔
63	"out",	4✔
64	"override",	4✔
65	"params",	4✔
66	"private",	4✔
67	"protected",	4✔
68	"public",	4✔
69	"readonly",	4✔
70	"ref",	4✔
71	"return",	4✔
72	"sbyte",	4✔
73	"sealed",	4✔
74	"short",	4✔
75	"sizeof",	4✔
76	"stackalloc",	4✔
77	"static",	4✔
78	"string",	4✔
79	"struct",	4✔
80	"switch",	4✔
81	"this",	4✔
82	"throw",	4✔
83	"true",	4✔
84	"try",	4✔
85	"typeof",	4✔
86	"uint",	4✔
87	"ulong",	4✔
88	"unchecked",	4✔
89	"unsafe",	4✔
90	"ushort",	4✔
91	"using",	4✔
92	"virtual",	4✔
93	"void",	4✔
94	"volatile",	4✔
95	"while"	4✔
96	];	4✔
97
98	/// <summary>
99	/// Get source code from contract Manifest
100	/// </summary>
101	/// <param name="manifest">Manifest</param>
102	/// <param name="name">Class name, by default is manifest.Name</param>
103	/// <param name="nef">Nef file</param>
104	/// <param name="generateProperties">Generate properties</param>
105	/// <returns>Source</returns>
106	public static string GetArtifactsSource(this ContractManifest manifest, string? name = null, NefFile? nef = null, bool generateProperties = true, JToken? debugInfo = null)
107	{	132✔
108	name ??= manifest.Name;	132!
109	var builder = new StringBuilder();	132✔
110	using var sourceCode = new StringWriter(builder)	132✔
111	{	132✔
112	NewLine = "\n"	132✔
113	};	132✔
114
115	var inheritance = new List<Type>	132✔
116	{	132✔
117	typeof(SmartContract)	132✔
118	};	132✔
119
120	if (manifest.IsNep17()) inheritance.Add(typeof(INep17Standard));	136✔
121	if (manifest.IsOwnable()) inheritance.Add(typeof(IOwnable));	134✔
122	if (manifest.IsVerificable()) inheritance.Add(typeof(IVerificable));	134✔
123
124	sourceCode.WriteLine("using Neo.Cryptography.ECC;");	132✔
125	sourceCode.WriteLine("using System;");	132✔
126	sourceCode.WriteLine("using System.Collections.Generic;");	132✔
127	sourceCode.WriteLine("using System.ComponentModel;");	132✔
128	sourceCode.WriteLine("using System.Numerics;");	132✔
129	sourceCode.WriteLine("");	132✔
130	sourceCode.WriteLine("namespace Neo.SmartContract.Testing;");	132✔
131	sourceCode.WriteLine("");	132✔
132	sourceCode.WriteLine($"public abstract class {name}({typeof(SmartContractInitialize).FullName} initialize) : " + FormatInheritance(inheritance, "initialize") + ", IContractInfo");	132✔
133	sourceCode.WriteLine("{");	132✔
134
135	// Write compiled data
136
137	sourceCode.WriteLine(" #region Compiled data");	132✔
138	sourceCode.WriteLine();	132✔
139
140	var value = manifest.ToJson().ToString(false).Replace("\"", "\"\"");	132✔
141	sourceCode.WriteLine($" public static {typeof(ContractManifest).FullName} Manifest => {typeof(ContractManifest).FullName}.Parse(@\"{value}\");");	132✔
142	sourceCode.WriteLine();	132✔
143
144	if (nef is not null)	132✔
145	{	131✔
146	value = Convert.ToBase64String(nef.ToArray()).Replace("\"", "\"\"");	131✔
147
148	var optimization = manifest.Extra?["nef"]?["optimization"]?.ToString();	131!
149
150	if (optimization != null)	131✔
151	{	131✔
152	sourceCode.WriteLine($" /// <summary>");	131✔
153	sourceCode.WriteLine($" /// Optimization: {optimization}");	131✔
154	sourceCode.WriteLine($" /// </summary>");	131✔
155	}	131✔
156	sourceCode.WriteLine($" public static {typeof(NefFile).FullName} Nef => Neo.IO.Helper.AsSerializable<{typeof(NefFile).FullName}>(Convert.FromBase64String(@\"{value}\"));");	131✔
157	sourceCode.WriteLine();	131✔
158	}	131✔
159
160	sourceCode.WriteLine(" #endregion");	132✔
161	sourceCode.WriteLine();	132✔
162
163	// Crete events
164
165	if (manifest.Abi.Events.Any())	132✔
166	{	11✔
167	sourceCode.WriteLine(" #region Events");	11✔
168	sourceCode.WriteLine();	11✔
169
170	foreach (var ev in manifest.Abi.Events.OrderBy(u => u.Name))	72✔
171	{	13✔
172	sourceCode.Write(CreateSourceEventFromManifest(ev, inheritance));	13✔
173	sourceCode.WriteLine();	13✔
174	}	13✔
175
176	sourceCode.WriteLine(" #endregion");	11✔
177	sourceCode.WriteLine();	11✔
178	}	11✔
179
180	// Create methods
181
182	var methods = manifest.Abi.Methods;	132✔
183
184	if (generateProperties)	132✔
185	{	132✔
186	(methods, var properties) = ProcessAbiMethods(manifest.Abi.Methods);	132✔
187
188	if (properties.Any())	132✔
189	{	10✔
190	sourceCode.WriteLine(" #region Properties");	10✔
191	sourceCode.WriteLine();	10✔
192
193	foreach (var property in properties.OrderBy(u => u.getter.Name))	126✔
194	{	32✔
195	sourceCode.Write(CreateSourcePropertyFromManifest(property.getter, property.setter));	32✔
196	sourceCode.WriteLine();	32✔
197	}	32✔
198
199	sourceCode.WriteLine(" #endregion");	10✔
200	sourceCode.WriteLine();	10✔
201	}	10✔
202	}	132✔
203
204	if (methods.Any(u => u.Safe))	1,136✔
205	{	7✔
206	sourceCode.WriteLine(" #region Safe methods");	7✔
207	sourceCode.WriteLine();	7✔
208
209	foreach (var method in methods.Where(u => u.Safe).OrderBy(u => u.Name))	112✔
210	{	15✔
211	// This method can't be called, so avoid them
212
213	if (method.Name.StartsWith("_")) continue;	15✔
214
215	sourceCode.Write(CreateSourceMethodFromManifest(method, nef, debugInfo));	15✔
216	sourceCode.WriteLine();	15✔
217	}	15✔
218
219	sourceCode.WriteLine(" #endregion");	7✔
220	sourceCode.WriteLine();	7✔
221	}	7✔
222
223	if (methods.Any(u => !u.Safe))	276✔
224	{	132✔
225	sourceCode.WriteLine(" #region Unsafe methods");	132✔
226	sourceCode.WriteLine();	132✔
227
228	foreach (var method in methods.Where(u => !u.Safe).OrderBy(u => u.Name))	4,519✔
229	{	1,027✔
230	// This method can't be called, so avoid them
231
232	if (method.Name.StartsWith("_")) continue;	1,057✔
233
234	sourceCode.Write(CreateSourceMethodFromManifest(method, nef, debugInfo));	997✔
235	sourceCode.WriteLine();	997✔
236	}	997✔
237	sourceCode.WriteLine(" #endregion");	132✔
238	}	132✔
239
240	sourceCode.WriteLine("}");	132✔
241
242	return sourceCode.ToString();	132✔
243	}	132✔
244
245	private static (ContractMethodDescriptor[] methods, (ContractMethodDescriptor getter, ContractMethodDescriptor? setter)[] properties)
246	ProcessAbiMethods(ContractMethodDescriptor[] methods)
247	{	132✔
248	HashSet<string> propertyNames = new();	132✔
249	List<ContractMethodDescriptor> methodList = new(methods);	132✔
250	List<(ContractMethodDescriptor, ContractMethodDescriptor?)> properties = new();	132✔
251
252	// Detect and extract properties, first find Safe && 0 args && return != void
253
254	foreach (ContractMethodDescriptor getter in methods.Where(u => u.Safe && u.Parameters.Length == 0 && u.ReturnType != ContractParameterType.Void).ToArray())	1,545✔
255	{	35✔
256	// Find setter: setXXX && one arg && not safe && parameter = getter.return && return == void
257
258	var setter = getter.Name.StartsWith("get") ? // Only find setter if start with get	35✔
259	methodList.FirstOrDefault(	35✔
260	u =>	35✔
261	u.Name == "set" + getter.Name[3..] &&	63✔
262	!u.Safe &&	63✔
263	u.Parameters.Length == 1 &&	63✔
264	u.Parameters[0].Type == getter.ReturnType &&	63✔
265	u.ReturnType == ContractParameterType.Void	63✔
266	) : null;	35✔
267
268	// Avoid property repetition
269
270	var propertyName = GetPropertyName(getter);	35✔
271	if (!propertyNames.Add(propertyName)) continue;	38✔
272
273	// Add property and remove method
274
275	properties.Add((getter, setter));	32✔
276	methodList.Remove(getter);	32✔
277
278	if (setter != null)	32✔
279	{	5✔
280	methodList.Remove(setter);	5✔
281	}	5✔
282	}	32✔
283
284	return (methodList.ToArray(), properties.ToArray());	132✔
285	}	132✔
286
287	private static string GetPropertyName(ContractMethodDescriptor getter)
288	{	67✔
289	return TongleLowercase(EscapeName(getter.Name.StartsWith("get") ? getter.Name[3..] : getter.Name));	67✔
290	}	67✔
291
292	/// <summary>
293	/// Create source code from event
294	/// </summary>
295	/// <param name="ev">Event</param>
296	/// <param name="inheritance">Inheritance</param>
297	/// <returns>Source</returns>
298	private static string CreateSourceEventFromManifest(ContractEventDescriptor ev, IList<Type> inheritance)
299	{	13✔
300	var builder = new StringBuilder();	13✔
301	using var sourceCode = new StringWriter(builder)	13✔
302	{	13✔
303	NewLine = "\n"	13✔
304	};	13✔
305
306	switch (ev.Name)	13✔
307	{
308	case "Transfer":
309	{	6✔
310	if (inheritance.Contains(typeof(INep17Standard)) && ev.Parameters.Length == 3 &&	6✔
311	ev.Parameters[0].Type == ContractParameterType.Hash160 &&	6✔
312	ev.Parameters[1].Type == ContractParameterType.Hash160 &&	6✔
313	ev.Parameters[2].Type == ContractParameterType.Integer)	6✔
314	{	4✔
315	sourceCode.WriteLine($" [DisplayName(\"{ev.Name}\")]");	4✔
316	sourceCode.WriteLine($" public event {typeof(INep17Standard).FullName}.delTransfer? OnTransfer;");	4✔
317	return builder.ToString();	4✔
318	}
319
320	break;	2✔
321	}
322	case "SetOwner":
323	{	3✔
324	if (inheritance.Contains(typeof(IOwnable)) && ev.Parameters.Length == 2 &&	3✔
325	ev.Parameters[0].Type == ContractParameterType.Hash160 &&	3✔
326	ev.Parameters[1].Type == ContractParameterType.Hash160)	3✔
327	{	2✔
328	sourceCode.WriteLine($" [DisplayName(\"{ev.Name}\")]");	2✔
329	sourceCode.WriteLine($" public event {typeof(IOwnable).FullName}.delSetOwner? OnSetOwner;");	2✔
330	return builder.ToString();	2✔
331	}
332
333	break;	1✔
334	}
335	}
336
337	// Add On prefix
338
339	var evName = TongleLowercase(EscapeName(ev.Name));	7✔
340	if (!evName.StartsWith("On")) evName = "On" + evName;	14✔
341
342	// Compose delegate
343
344	sourceCode.Write($" public delegate void del{ev.Name}(");	7✔
345
346	var isFirst = true;	7✔
347	foreach (var arg in ev.Parameters)	51✔
348	{	15✔
349	if (!isFirst) sourceCode.Write(", ");	23✔
350	else isFirst = false;	7✔
351
352	sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)}");	15✔
353	}	15✔
354
355	sourceCode.WriteLine(");");	7✔
356	sourceCode.WriteLine();	7✔
357
358	// Compose event
359
360	if (ev.Name != evName)	7✔
361	{	7✔
362	sourceCode.WriteLine($" [DisplayName(\"{ev.Name}\")]");	7✔
363	}	7✔
364	sourceCode.WriteLine($" public event del{ev.Name}? {evName};");	7✔
365
366	return builder.ToString();	7✔
367	}	13✔
368
369	/// <summary>
370	/// Create source code from manifest property
371	/// </summary>
372	/// <param name="getter">Getter</param>
373	/// <param name="setter">Setter</param>
374	/// <returns>Source</returns>
375	private static string CreateSourcePropertyFromManifest(ContractMethodDescriptor getter, ContractMethodDescriptor? setter)
376	{	32✔
377	var propertyName = GetPropertyName(getter);	32✔
378	var getset = setter is not null ? $"{{ [DisplayName(\"{getter.Name}\")] get; [DisplayName(\"{setter.Name}\")] set; }}" : $"{{ [DisplayName(\"{getter.Name}\")] get; }}";	32✔
379
380	var builder = new StringBuilder();	32✔
381	using var sourceCode = new StringWriter(builder)	32✔
382	{	32✔
383	NewLine = "\n"	32✔
384	};	32✔
385
386	sourceCode.WriteLine($" /// <summary>");	32✔
387	sourceCode.WriteLine($" /// {(getter.Safe ? "Safe property" : "Unsafe property")}");	32!
388	sourceCode.WriteLine($" /// </summary>");	32✔
389	sourceCode.WriteLine($" public abstract {TypeToSource(getter.ReturnType)} {propertyName} {getset}");	32✔
390
391	return builder.ToString();	32✔
392	}	32✔
393
394	/// <summary>
395	/// Create source code from manifest method
396	/// </summary>
397	/// <param name="method">Contract method</param>
398	/// <param name="nefFile">Nef File</param>
399	/// <param name="debugInfo">Debug info</param>
400	/// <returns>Source</returns>
401	private static string CreateSourceMethodFromManifest(ContractMethodDescriptor method, NefFile? nefFile = null, JToken? debugInfo = null)
402	{	1,012✔
403	var methodName = TongleLowercase(EscapeName(method.Name));	1,012✔
404
405	var builder = new StringBuilder();	1,012✔
406	using var sourceCode = new StringWriter(builder)	1,012✔
407	{	1,012✔
408	NewLine = "\n"	1,012✔
409	};	1,012✔
410
411	sourceCode.WriteLine($" /// <summary>");	1,012✔
412	sourceCode.WriteLine($" /// {(method.Safe ? "Safe method" : "Unsafe method")}");	1,012✔
413	sourceCode.WriteLine($" /// </summary>");	1,012✔
414
415	// Add the opcodes
416	if (debugInfo != null && nefFile != null)	1,012✔
417	{	1,004✔
418	var instructions = Disassembler.CSharp.Disassembler.ConvertMethodToInstructions(nefFile, debugInfo, method.Name, method.Parameters.Length);	1,004✔
419	if (instructions is not null && instructions.Count > 0)	1,004!
420	{	1,003✔
421	Script script = nefFile.Script;	1,003✔
422	(var start, var end, _) = Disassembler.CSharp.Disassembler.GetMethodStartEndAddress(method.Name, method.Parameters.Length, debugInfo);	1,003✔
423	var actualEnd = end + script.GetInstruction(end).Size;	1,003✔
424	var scripts = nefFile.Script[start..actualEnd].ToArray();	1,003✔
425
426	var maxAddressLength = instructions.Max(instruction => instruction.address.ToString("X").Length);	18,322✔
427	var addressFormat = $"X{(maxAddressLength + 1) / 2 * 2}";	1,003✔
428
429	sourceCode.WriteLine(" /// <remarks>");	1,003✔
430	sourceCode.WriteLine($" /// Script: {Convert.ToBase64String(scripts)}");	1,003✔
431	foreach (var instruction in instructions)	37,647✔
432	{	17,319✔
433	sourceCode.WriteLine($" /// {instruction.address.ToString(addressFormat)} : {instruction.instruction.InstructionToString(true)}");	17,319✔
434	}	17,319✔
435	sourceCode.WriteLine(" /// </remarks>");	1,003✔
436	}	1,003✔
437	}	1,004✔
438
439	if (method.Name != methodName)	1,012✔
440	{	999✔
441	sourceCode.WriteLine($" [DisplayName(\"{method.Name}\")]");	999✔
442	}	999✔
443	sourceCode.Write($" public abstract {TypeToSource(method.ReturnType)} {methodName}(");	1,012✔
444
445	var isFirst = true;	1,012✔
446	for (int x = 0; x < method.Parameters.Length; x++)	4,094✔
447	{	1,035✔
448	if (!isFirst) sourceCode.Write(", ");	1,398✔
449	else isFirst = false;	672✔
450
451	var isLast = x == method.Parameters.Length - 1;	1,035✔
452	var arg = method.Parameters[x];	1,035✔
453
454	if (isLast && arg.Type == ContractParameterType.Any)	1,035✔
455	{	30✔
456	// it will be `object X`, we can add a default value
457
458	sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)} = null");	30✔
459	}	30✔
460	else
461	{	1,005✔
462	sourceCode.Write($"{TypeToSource(arg.Type)} {EscapeName(arg.Name)}");	1,005✔
463	}	1,005✔
464	}	1,035✔
465
466	sourceCode.WriteLine(");");	1,012✔
467
468	return builder.ToString();	1,012✔
469	}	1,012✔
470
471	private static string TongleLowercase(string value)
472	{	1,086✔
473	if (value.Length == 0)	1,086!
UNCOV 474	{	×
UNCOV 475	return value;	×
476	}
477
478	if (char.IsLower(value[0]))	1,086✔
479	{	1,052✔
480	return value[0].ToString().ToUpperInvariant() + value[1..];	1,052✔
481	}
482
483	return value;	34✔
484	}	1,086✔
485
486	/// <summary>
487	/// Escape name
488	/// </summary>
489	/// <param name="name">Name</param>
490	/// <returns>Escaped name</returns>
491	private static string EscapeName(string name)
492	{	2,136✔
493	if (_protectedWords.Contains(name))	2,136✔
494	return "@" + name;	2✔
495
496	return name;	2,134✔
497	}	2,136✔
498
499	/// <summary>
500	/// Type to source
501	/// </summary>
502	/// <param name="type">Type</param>
503	/// <returns>c# type</returns>
504	private static string TypeToSource(ContractParameterType type)
505	{	2,094✔
506	return type switch	2,094!
507	{	2,094✔
508	ContractParameterType.Boolean => "bool?",	340✔
509	ContractParameterType.Integer => "BigInteger?",	1,021✔
510	ContractParameterType.String => "string?",	205✔
511	ContractParameterType.Hash160 => "UInt160?",	76✔
512	ContractParameterType.Hash256 => "UInt256?",	18✔
513	ContractParameterType.PublicKey => "ECPoint?",	10✔
514	ContractParameterType.ByteArray => "byte[]?",	125✔
UNCOV 515	ContractParameterType.Signature => "byte[]?",	×
516	ContractParameterType.Array => "IList<object>?",	118✔
517	ContractParameterType.Map => "IDictionary<object, object>?",	4✔
518	ContractParameterType.Void => "void",	70✔
519	_ => "object?",	107✔
520	};	2,094✔
521	}	2,094✔
522
523	private static string FormatInheritance(List<Type> inheritance, string initializeParam)
524	{	132✔
525	var formattedInheritance = inheritance.Select(type => (type == typeof(SmartContract)	272✔
526	? $"{type.FullName}({initializeParam})"	272✔
527	: type.FullName)!)	272✔
528	.ToList();	132✔
529	return string.Join(", ", formattedInheritance);	132✔
530	}	132✔
531	}
532	}

neo-project / neo-devpack-dotnet / 11747354015

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous