11710049443

Committed 06 Nov 2024 06:54PM UTC coverage: 74.025% (-0.5%) from 74.571%

Build # 11710049443

Build Type

push

github

Committed by

web-flow

Commit Message

update nepcheck (#1227)

* update nepcheck

* Update src/Neo.Compiler.CSharp/Manifest/ContractManifestExtensions.Nep17.cs

---------

Co-authored-by: Shargon <shargon@gmail.com>

Run Details

4826 of 7084 branches covered (68.13%)

Branch coverage included in aggregate %.

65 of 230 new or added lines in 3 files covered. (28.26%)

14 existing lines in 3 files now uncovered.

12906 of 16870 relevant lines covered (76.5%)

17677.03 hits per line

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

47.51

/src/Neo.Compiler.CSharp/Manifest/ContractManifestExtensions.Nep17.cs

extern alias scfx;
using System.Linq;
using Neo.SmartContract.Manifest;
using scfx::Neo.SmartContract.Framework;
using ContractParameterType = Neo.SmartContract.ContractParameterType;

namespace Neo.Compiler;

internal static partial class ContractManifestExtensions
{
    private static System.Collections.Generic.List<CompilationException>
        CheckNep17Compliant(this ContractManifest manifest)
    {
        System.Collections.Generic.List<CompilationException> errors = [];

        var symbolMethod = manifest.Abi.GetMethod("symbol", 0);
        var decimalsMethod = manifest.Abi.GetMethod("decimals", 0);
        var totalSupplyMethod = manifest.Abi.GetMethod("totalSupply", 0);
        var balanceOfMethod = manifest.Abi.GetMethod("balanceOf", 1);
        var transferMethod = manifest.Abi.GetMethod("transfer", 4);

        // Check symbol method
        if (symbolMethod == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it is not found in the ABI"));

        if (symbolMethod is { Safe: false })
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it is not safe, you should add a 'Safe' attribute to the symbol method"));

        if (symbolMethod != null && symbolMethod.ReturnType != ContractParameterType.String)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it's return type is not a String"));

        // Check decimals method
        if (decimalsMethod == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it is not found in the ABI"));

        if (decimalsMethod is { Safe: false })
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it is not safe, you should add a 'Safe' attribute to the decimals method"));

        if (decimalsMethod != null && decimalsMethod.ReturnType != ContractParameterType.Integer)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it's return type is not an Integer"));

        // Check totalSupply method
        if (totalSupplyMethod == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it is not found in the ABI"));

        if (totalSupplyMethod is { Safe: false })
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it is not safe, you should add a 'Safe' attribute to the totalSupply method"));

        if (totalSupplyMethod != null && totalSupplyMethod.ReturnType != ContractParameterType.Integer)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it's return type is not an Integer"));

        // Check balanceOf method
        if (balanceOfMethod == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it is not found in the ABI"));

        if (balanceOfMethod is { Safe: false })
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it is not safe, you should add a 'Safe' attribute to the balanceOf method"));

        if (balanceOfMethod != null && balanceOfMethod.ReturnType != ContractParameterType.Integer)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's return type is not an Integer"));

        if (balanceOfMethod != null && balanceOfMethod.Parameters.Length != 1)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's parameters length is not 1"));

        if (balanceOfMethod != null && balanceOfMethod.Parameters[0].Type != ContractParameterType.Hash160)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's parameter type is not a Hash160"));

        // Check transfer method
        if (transferMethod == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it is not found in the ABI"));

        // Note: transfer method should NOT be safe as per NEP-17 standard
        if (transferMethod != null && transferMethod.Safe)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it should not be marked as Safe"));

        if (transferMethod != null && transferMethod.ReturnType != ContractParameterType.Boolean)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's return type is not a Boolean"));

        if (transferMethod != null && transferMethod.Parameters.Length != 4)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's parameters length is not 4"));

        if (transferMethod != null && transferMethod.Parameters.Length == 4)
        {
            if (transferMethod.Parameters[0].Type != ContractParameterType.Hash160)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's first parameter (from) type is not a Hash160"));

            if (transferMethod.Parameters[1].Type != ContractParameterType.Hash160)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's second parameter (to) type is not a Hash160"));

            if (transferMethod.Parameters[2].Type != ContractParameterType.Integer)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's third parameter (amount) type is not an Integer"));

            if (transferMethod.Parameters[3].Type != ContractParameterType.Any)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's fourth parameter (data) type is not Any"));
        }

        // Check Transfer event
        var transferEvent = manifest.Abi.Events.FirstOrDefault(e =>
            e.Name == "Transfer");

        if (transferEvent == null)
            errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                $"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event is not found in the ABI"));
        else
        {
            if (transferEvent.Parameters.Length != 3)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event parameters length is not 3"));

            if (transferEvent.Parameters[0].Type != ContractParameterType.Hash160)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event first parameter (from) type is not Hash160"));

            if (transferEvent.Parameters[1].Type != ContractParameterType.Hash160)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event second parameter (to) type is not Hash160"));

            if (transferEvent.Parameters[2].Type != ContractParameterType.Integer)
                errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,
                    $"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event third parameter (amount) type is not Integer"));
        }

        return errors;
    }
}

1	extern alias scfx;
2	using System.Linq;
3	using Neo.SmartContract.Manifest;
4	using scfx::Neo.SmartContract.Framework;
5	using ContractParameterType = Neo.SmartContract.ContractParameterType;
6
7	namespace Neo.Compiler;
8
9	internal static partial class ContractManifestExtensions
10	{
11	private static System.Collections.Generic.List<CompilationException>
12	CheckNep17Compliant(this ContractManifest manifest)
13	{	3✔
14	System.Collections.Generic.List<CompilationException> errors = [];	3✔
15
16	var symbolMethod = manifest.Abi.GetMethod("symbol", 0);	3✔
17	var decimalsMethod = manifest.Abi.GetMethod("decimals", 0);	3✔
18	var totalSupplyMethod = manifest.Abi.GetMethod("totalSupply", 0);	3✔
19	var balanceOfMethod = manifest.Abi.GetMethod("balanceOf", 1);	3✔
20	var transferMethod = manifest.Abi.GetMethod("transfer", 4);	3✔
21
22	// Check symbol method
23	if (symbolMethod == null)	3!
NEW 24	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 25	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it is not found in the ABI"));	×
26
27	if (symbolMethod is { Safe: false })	3!
NEW 28	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 29	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it is not safe, you should add a 'Safe' attribute to the symbol method"));	×
30
31	if (symbolMethod != null && symbolMethod.ReturnType != ContractParameterType.String)	3!
NEW 32	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 33	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: symbol, it's return type is not a String"));	×
34
35	// Check decimals method
36	if (decimalsMethod == null)	3!
NEW 37	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 38	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it is not found in the ABI"));	×
39
40	if (decimalsMethod is { Safe: false })	3!
NEW 41	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 42	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it is not safe, you should add a 'Safe' attribute to the decimals method"));	×
43
44	if (decimalsMethod != null && decimalsMethod.ReturnType != ContractParameterType.Integer)	3!
NEW 45	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 46	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: decimals, it's return type is not an Integer"));	×
47
48	// Check totalSupply method
49	if (totalSupplyMethod == null)	3!
NEW 50	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 51	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it is not found in the ABI"));	×
52
53	if (totalSupplyMethod is { Safe: false })	3!
NEW 54	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 55	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it is not safe, you should add a 'Safe' attribute to the totalSupply method"));	×
56
57	if (totalSupplyMethod != null && totalSupplyMethod.ReturnType != ContractParameterType.Integer)	3!
NEW 58	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 59	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: totalSupply, it's return type is not an Integer"));	×
60
61	// Check balanceOf method
62	if (balanceOfMethod == null)	3!
NEW 63	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 64	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it is not found in the ABI"));	×
65
66	if (balanceOfMethod is { Safe: false })	3!
NEW 67	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 68	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it is not safe, you should add a 'Safe' attribute to the balanceOf method"));	×
69
70	if (balanceOfMethod != null && balanceOfMethod.ReturnType != ContractParameterType.Integer)	3!
NEW 71	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 72	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's return type is not an Integer"));	×
73
74	if (balanceOfMethod != null && balanceOfMethod.Parameters.Length != 1)	3!
NEW 75	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 76	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's parameters length is not 1"));	×
77
78	if (balanceOfMethod != null && balanceOfMethod.Parameters[0].Type != ContractParameterType.Hash160)	3!
NEW 79	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 80	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: balanceOf, it's parameter type is not a Hash160"));	×
81
82	// Check transfer method
83	if (transferMethod == null)	3!
NEW 84	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 85	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it is not found in the ABI"));	×
86
87	// Note: transfer method should NOT be safe as per NEP-17 standard
88	if (transferMethod != null && transferMethod.Safe)	3!
NEW 89	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 90	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it should not be marked as Safe"));	×
91
92	if (transferMethod != null && transferMethod.ReturnType != ContractParameterType.Boolean)	3!
NEW 93	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 94	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's return type is not a Boolean"));	×
95
96	if (transferMethod != null && transferMethod.Parameters.Length != 4)	3!
NEW 97	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 98	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's parameters length is not 4"));	×
99
100	if (transferMethod != null && transferMethod.Parameters.Length == 4)	3!
101	{	3✔
102	if (transferMethod.Parameters[0].Type != ContractParameterType.Hash160)	3!
NEW 103	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 104	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's first parameter (from) type is not a Hash160"));	×
105
106	if (transferMethod.Parameters[1].Type != ContractParameterType.Hash160)	3!
NEW 107	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 108	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's second parameter (to) type is not a Hash160"));	×
109
110	if (transferMethod.Parameters[2].Type != ContractParameterType.Integer)	3!
NEW 111	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 112	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's third parameter (amount) type is not an Integer"));	×
113
114	if (transferMethod.Parameters[3].Type != ContractParameterType.Any)	3!
NEW 115	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 116	$"Incomplete or unsafe NEP standard {NepStandard.Nep17.ToStandard()} implementation: transfer, it's fourth parameter (data) type is not Any"));	×
117	}	3✔
118
119	// Check Transfer event
120	var transferEvent = manifest.Abi.Events.FirstOrDefault(e =>	3✔
121	e.Name == "Transfer");	6✔
122
123	if (transferEvent == null)	3!
NEW 124	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 125	$"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event is not found in the ABI"));	×
126	else
127	{	3✔
128	if (transferEvent.Parameters.Length != 3)	3!
NEW 129	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 130	$"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event parameters length is not 3"));	×
131
132	if (transferEvent.Parameters[0].Type != ContractParameterType.Hash160)	3!
NEW 133	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 134	$"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event first parameter (from) type is not Hash160"));	×
135
136	if (transferEvent.Parameters[1].Type != ContractParameterType.Hash160)	3!
NEW 137	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 138	$"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event second parameter (to) type is not Hash160"));	×
139
140	if (transferEvent.Parameters[2].Type != ContractParameterType.Integer)	3!
NEW 141	errors.Add(new CompilationException(DiagnosticId.IncorrectNEPStandard,	×
NEW 142	$"Incomplete NEP standard {NepStandard.Nep17.ToStandard()} implementation: Transfer event third parameter (amount) type is not Integer"));	×
143	}	3✔
144
145	return errors;	3✔
146	}	3✔
147	}

neo-project / neo-devpack-dotnet / 11710049443

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