Implement NEP-17 (#2024)

shargon · erikzhang · Tommo-L · web-flow · commit 72eb3e68c12a · 2020-11-18T16:57:36.000+01:00
* If exists

* Call onPayment if to it's a smart contract

* Increase cost in transfer

* Remove Mint check

* return

* Remove extra args

* Drop result

* Clean code

* Method.Exists

* Rename

* protected

* Update ApplicationEngine.Contract.cs

* Fix merge

* Add Name in Extra

* Name in manifest

* Fix UT

* dotnet format

* Remove Method.Exists

* Clean code

* Move filed `Name`

* Rename

* Update null checks

* Fix CallFromNativeContract parameters

* Update AssetDescriptor.cs

* Fix UT

* format

* Shargon's suggestion

* Update src/neo/SmartContract/Native/Tokens/Nep17Token.cs

Co-authored-by: Luchuan &lt;luchuan@ngd.neo.org&gt;

* Fix

Co-authored-by: Erik Zhang &lt;erik@neo.org&gt;
Co-authored-by: Luchuan &lt;luchuan@ngd.neo.org&gt;
diff --git a/src/neo/SmartContract/Manifest/ContractManifest.cs b/src/neo/SmartContract/Manifest/ContractManifest.cs
@@ -34,6 +34,11 @@ public int Size
         /// </summary>
         public UInt160 Hash => Abi.Hash;
 
+        /// <summary>
+        /// Contract name
+        /// </summary>
+        public string Name { 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.
         /// </summary>
@@ -110,6 +115,7 @@ public JObject ToJson()
         {
             return new JObject
             {
+                ["name"] = Name,
                 ["groups"] = Groups.Select(u => u.ToJson()).ToArray(),
                 ["supportedstandards"] = SupportedStandards.Select(u => new JString(u)).ToArray(),
                 ["abi"] = Abi.ToJson(),
@@ -128,6 +134,7 @@ public ContractManifest Clone()
         {
             return new ContractManifest
             {
+                Name = Name,
                 Groups = Groups.Select(p => p.Clone()).ToArray(),
                 SupportedStandards = SupportedStandards[..],
                 Abi = Abi.Clone(),
@@ -156,6 +163,7 @@ public void Deserialize(BinaryReader reader)
 
         private void DeserializeFromJson(JObject json)
         {
+            Name = json["name"].AsString();
             Groups = ((JArray)json["groups"]).Select(u => ContractGroup.FromJson(u)).ToArray();
             SupportedStandards = ((JArray)json["supportedstandards"]).Select(u => u.AsString()).ToArray();
             Abi = ContractAbi.FromJson(json["abi"]);
diff --git a/src/neo/SmartContract/Native/NativeContract.cs b/src/neo/SmartContract/Native/NativeContract.cs
@@ -62,6 +62,7 @@ protected NativeContract()
             }
             this.Manifest = new ContractManifest
             {
+                Name = Name,
                 Groups = System.Array.Empty<ContractGroup>(),
                 SupportedStandards = new string[0],
                 Abi = new ContractAbi()
diff --git a/src/neo/SmartContract/Native/Tokens/GasToken.cs b/src/neo/SmartContract/Native/Tokens/GasToken.cs
@@ -4,7 +4,7 @@
 
 namespace Neo.SmartContract.Native.Tokens
 {
-    public sealed class GasToken : Nep5Token<AccountState>
+    public sealed class GasToken : Nep17Token<AccountState>
     {
         public override int Id => -2;
         public override string Name => "GAS";
diff --git a/src/neo/SmartContract/Native/Tokens/NeoToken.cs b/src/neo/SmartContract/Native/Tokens/NeoToken.cs
@@ -15,7 +15,7 @@
 
 namespace Neo.SmartContract.Native.Tokens
 {
-    public sealed class NeoToken : Nep5Token<NeoToken.NeoAccountState>
+    public sealed class NeoToken : Nep17Token<NeoToken.NeoAccountState>
     {
         public override int Id => -1;
         public override string Name => "NEO";
diff --git a/src/neo/SmartContract/Native/Tokens/Nep17Token.cs b/src/neo/SmartContract/Native/Tokens/Nep17Token.cs
@@ -10,7 +10,7 @@
 
 namespace Neo.SmartContract.Native.Tokens
 {
-    public abstract class Nep5Token<TState> : NativeContract
+    public abstract class Nep17Token<TState> : NativeContract
         where TState : AccountState, new()
     {
         [ContractMethod(0, CallFlags.None)]
@@ -22,11 +22,11 @@ public abstract class Nep5Token<TState> : NativeContract
         protected const byte Prefix_TotalSupply = 11;
         protected const byte Prefix_Account = 20;
 
-        protected Nep5Token()
+        protected Nep17Token()
         {
             this.Factor = BigInteger.Pow(10, Decimals);
 
-            Manifest.SupportedStandards = new[] { "NEP-5" };
+            Manifest.SupportedStandards = new[] { "NEP-17" };
 
             var events = new List<ContractEventDescriptor>(Manifest.Abi.Events)
             {
@@ -67,7 +67,7 @@ internal protected virtual void Mint(ApplicationEngine engine, UInt160 account,
             state.Balance += amount;
             storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_TotalSupply), () => new StorageItem(BigInteger.Zero));
             storage.Add(amount);
-            engine.SendNotification(Hash, "Transfer", new Array { StackItem.Null, account.ToArray(), amount });
+            PostTransfer(engine, null, account, amount);
         }
 
         internal protected virtual void Burn(ApplicationEngine engine, UInt160 account, BigInteger amount)
@@ -85,7 +85,7 @@ internal protected virtual void Burn(ApplicationEngine engine, UInt160 account,
                 state.Balance -= amount;
             storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_TotalSupply));
             storage.Add(-amount);
-            engine.SendNotification(Hash, "Transfer", new Array { account.ToArray(), StackItem.Null, amount });
+            PostTransfer(engine, account, null, amount);
         }
 
         [ContractMethod(0_01000000, CallFlags.AllowStates)]
@@ -104,7 +104,7 @@ public virtual BigInteger BalanceOf(StoreView snapshot, UInt160 account)
             return storage.GetInteroperable<TState>().Balance;
         }
 
-        [ContractMethod(0_08000000, CallFlags.AllowModifyStates)]
+        [ContractMethod(0_09000000, CallFlags.AllowModifyStates)]
         protected virtual bool Transfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount)
         {
             if (amount.Sign < 0) throw new ArgumentOutOfRangeException(nameof(amount));
@@ -143,12 +143,28 @@ protected virtual bool Transfer(ApplicationEngine engine, UInt160 from, UInt160
                     state_to.Balance += amount;
                 }
             }
-            engine.SendNotification(Hash, "Transfer", new Array { from.ToArray(), to.ToArray(), amount });
+            PostTransfer(engine, from, to, amount);
             return true;
         }
 
         protected virtual void OnBalanceChanging(ApplicationEngine engine, UInt160 account, TState state, BigInteger amount)
         {
         }
+
+        private void PostTransfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount)
+        {
+            // Send notification
+
+            engine.SendNotification(Hash, "Transfer",
+                new Array { from?.ToArray() ?? StackItem.Null, to?.ToArray() ?? StackItem.Null, amount });
+
+            // Check if it's a wallet or smart contract
+
+            if (to is null || engine.Snapshot.Contracts.TryGet(to) is null) return;
+
+            // Call onPayment method if exists (NEP-17)
+
+            engine.CallFromNativeContract(() => { }, to, "onPayment", from.ToArray(), amount);
+        }
     }
 }
diff --git a/src/neo/Wallets/AssetDescriptor.cs b/src/neo/Wallets/AssetDescriptor.cs
@@ -1,3 +1,5 @@
+using Neo.Ledger;
+using Neo.Persistence;
 using Neo.SmartContract;
 using Neo.VM;
 using System;
@@ -12,17 +14,20 @@ public class AssetDescriptor
 
         public AssetDescriptor(UInt160 asset_id)
         {
+            using SnapshotView snapshot = Blockchain.Singleton.GetSnapshot();
+            var contract = snapshot.Contracts.TryGet(asset_id);
+            if (contract is null) throw new ArgumentException();
+
             byte[] script;
             using (ScriptBuilder sb = new ScriptBuilder())
             {
                 sb.EmitAppCall(asset_id, "decimals");
-                sb.EmitAppCall(asset_id, "name");
                 script = sb.ToArray();
             }
-            using ApplicationEngine engine = ApplicationEngine.Run(script, gas: 3_000_000);
+            using ApplicationEngine engine = ApplicationEngine.Run(script, snapshot, gas: 0_02000000);
             if (engine.State.HasFlag(VMState.FAULT)) throw new ArgumentException();
             this.AssetId = asset_id;
-            this.AssetName = engine.ResultStack.Pop().GetString();
+            this.AssetName = contract.Manifest.Name;
             this.Decimals = (byte)engine.ResultStack.Pop().GetInteger();
         }
 
diff --git a/tests/neo.UnitTests/Ledger/UT_ContractState.cs b/tests/neo.UnitTests/Ledger/UT_ContractState.cs
@@ -72,7 +72,7 @@ public void TestDeserialize()
         public void TestGetSize()
         {
             ISerializable newContract = contract;
-            newContract.Size.Should().Be(218);
+            newContract.Size.Should().Be(240);
         }
 
         [TestMethod]
diff --git a/tests/neo.UnitTests/SmartContract/Manifest/UT_ContractManifest.cs b/tests/neo.UnitTests/SmartContract/Manifest/UT_ContractManifest.cs
@@ -11,7 +11,7 @@ public class UT_ContractManifest
         [TestMethod]
         public void ParseFromJson_Default()
         {
-            var json = @"{""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":null}";
+            var json = @"{""name"":""testManifest"",""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":null}";
             var manifest = ContractManifest.Parse(json);
 
             Assert.AreEqual(manifest.ToString(), json);
@@ -22,7 +22,7 @@ public void ParseFromJson_Default()
         [TestMethod]
         public void ParseFromJson_Permissions()
         {
-            var json = @"{""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""0x0000000000000000000000000000000000000000"",""methods"":[""method1"",""method2""]}],""trusts"":[],""safemethods"":[],""extra"":null}";
+            var json = @"{""name"":""testManifest"",""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""0x0000000000000000000000000000000000000000"",""methods"":[""method1"",""method2""]}],""trusts"":[],""safemethods"":[],""extra"":null}";
             var manifest = ContractManifest.Parse(json);
             Assert.AreEqual(manifest.ToString(), json);
 
@@ -41,7 +41,7 @@ public void ParseFromJson_Permissions()
         [TestMethod]
         public void ParseFromJson_SafeMethods()
         {
-            var json = @"{""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[""balanceOf""],""extra"":null}";
+            var json = @"{""name"":""testManifest"",""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[""balanceOf""],""extra"":null}";
             var manifest = ContractManifest.Parse(json);
             Assert.AreEqual(manifest.ToString(), json);
 
@@ -53,7 +53,7 @@ public void ParseFromJson_SafeMethods()
         [TestMethod]
         public void ParseFromJson_Trust()
         {
-            var json = @"{""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[""0x0000000000000000000000000000000000000001""],""safemethods"":[],""extra"":null}";
+            var json = @"{""name"":""testManifest"",""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[""0x0000000000000000000000000000000000000001""],""safemethods"":[],""extra"":null}";
             var manifest = ContractManifest.Parse(json);
             Assert.AreEqual(manifest.ToString(), json);
 
@@ -65,7 +65,7 @@ public void ParseFromJson_Trust()
         [TestMethod]
         public void ParseFromJson_Groups()
         {
-            var json = @"{""groups"":[{""pubkey"":""03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c"",""signature"":""QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQQ==""}],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":null}";
+            var json = @"{""name"":""testManifest"",""groups"":[{""pubkey"":""03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c"",""signature"":""QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQQ==""}],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":null}";
             var manifest = ContractManifest.Parse(json);
             Assert.AreEqual(manifest.ToString(), json);
 
@@ -77,7 +77,7 @@ public void ParseFromJson_Groups()
         [TestMethod]
         public void ParseFromJson_Extra()
         {
-            var json = @"{""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":{""key"":""value""}}";
+            var json = @"{""name"":""testManifest"",""groups"":[],""supportedstandards"":[],""abi"":{""hash"":""0x0000000000000000000000000000000000000000"",""methods"":[],""events"":[]},""permissions"":[{""contract"":""*"",""methods"":""*""}],""trusts"":[],""safemethods"":[],""extra"":{""key"":""value""}}";
             var manifest = ContractManifest.Parse(json);
             Assert.AreEqual(json, json);
             Assert.AreEqual("value", manifest.Extra["key"].AsString(), false);
@@ -110,7 +110,7 @@ public void TestGetHash()
         public void TestGetSize()
         {
             var temp = TestUtils.CreateDefaultManifest(UInt160.Zero);
-            Assert.AreEqual(212, temp.Size);
+            Assert.AreEqual(234, temp.Size);
         }
 
         [TestMethod]
diff --git a/tests/neo.UnitTests/SmartContract/Native/Tokens/UT_Nep17Token.cs b/tests/neo.UnitTests/SmartContract/Native/Tokens/UT_Nep17Token.cs
@@ -9,7 +9,7 @@
 namespace Neo.UnitTests.SmartContract.Native.Tokens
 {
     [TestClass]
-    public class UT_Nep5Token : TestKit
+    public class UT_Nep17Token : TestKit
     {
         [TestInitialize]
         public void TestSetup()
@@ -18,7 +18,13 @@ public void TestSetup()
         }
 
         protected const byte Prefix_TotalSupply = 11;
-        private static readonly TestNep5Token test = new TestNep5Token();
+        private static readonly TestNep17Token test = new TestNep17Token();
+
+        [TestMethod]
+        public void TestName()
+        {
+            Assert.AreEqual(test.Name, test.Manifest.Name);
+        }
 
         [TestMethod]
         public void TestTotalSupply()
@@ -71,11 +77,11 @@ public StorageKey CreateStorageKey(byte prefix, byte[] key = null)
         }
     }
 
-    public class TestNep5Token : Nep5Token<NeoToken.NeoAccountState>
+    public class TestNep17Token : Nep17Token<NeoToken.NeoAccountState>
     {
         public override int Id => 0x10000005;
 
-        public override string Name => "testNep5Token";
+        public override string Name => "testNep17Token";
 
         public override string Symbol => throw new NotImplementedException();
 
diff --git a/tests/neo.UnitTests/TestUtils.cs b/tests/neo.UnitTests/TestUtils.cs
@@ -22,6 +22,7 @@ public static ContractManifest CreateDefaultManifest(UInt160 hash)
         {
             return new ContractManifest()
             {
+                Name = "testManifest",
                 Groups = new ContractGroup[0],
                 SupportedStandards = Array.Empty<string>(),
                 Abi = new ContractAbi()
diff --git a/tests/neo.UnitTests/Wallets/UT_AssetDescriptor.cs b/tests/neo.UnitTests/Wallets/UT_AssetDescriptor.cs
@@ -1,6 +1,5 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Neo.Persistence;
 using Neo.SmartContract.Native;
 using System;
 

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ protected NativeContract()`
`62`	`62`	`}`
`63`	`63`	`this.Manifest = new ContractManifest`
`64`	`64`	`{`
	`65`	`+ Name = Name,`
`65`	`66`	`Groups = System.Array.Empty<ContractGroup>(),`
`66`	`67`	`SupportedStandards = new string[0],`
`67`	`68`	`Abi = new ContractAbi()`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace Neo.SmartContract.Native.Tokens`
`6`	`6`	`{`
`7`		`- public sealed class GasToken : Nep5Token<AccountState>`
	`7`	`+ public sealed class GasToken : Nep17Token<AccountState>`
`8`	`8`	`{`
`9`	`9`	`public override int Id => -2;`
`10`	`10`	`public override string Name => "GAS";`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`
`16`	`16`	`namespace Neo.SmartContract.Native.Tokens`
`17`	`17`	`{`
`18`		`- public sealed class NeoToken : Nep5Token<NeoToken.NeoAccountState>`
	`18`	`+ public sealed class NeoToken : Nep17Token<NeoToken.NeoAccountState>`
`19`	`19`	`{`
`20`	`20`	`public override int Id => -1;`
`21`	`21`	`public override string Name => "NEO";`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`namespace Neo.SmartContract.Native.Tokens`
`12`	`12`	`{`
`13`		`- public abstract class Nep5Token<TState> : NativeContract`
	`13`	`+ public abstract class Nep17Token<TState> : NativeContract`
`14`	`14`	`where TState : AccountState, new()`
`15`	`15`	`{`
`16`	`16`	`[ContractMethod(0, CallFlags.None)]`
`@@ -22,11 +22,11 @@ public abstract class Nep5Token<TState> : NativeContract`
`22`	`22`	`protected const byte Prefix_TotalSupply = 11;`
`23`	`23`	`protected const byte Prefix_Account = 20;`
`24`	`24`
`25`		`- protected Nep5Token()`
	`25`	`+ protected Nep17Token()`
`26`	`26`	`{`
`27`	`27`	`this.Factor = BigInteger.Pow(10, Decimals);`
`28`	`28`
`29`		`- Manifest.SupportedStandards = new[] { "NEP-5" };`
	`29`	`+ Manifest.SupportedStandards = new[] { "NEP-17" };`
`30`	`30`
`31`	`31`	`var events = new List<ContractEventDescriptor>(Manifest.Abi.Events)`
`32`	`32`	`{`
`@@ -67,7 +67,7 @@ internal protected virtual void Mint(ApplicationEngine engine, UInt160 account,`
`67`	`67`	`state.Balance += amount;`
`68`	`68`	`storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_TotalSupply), () => new StorageItem(BigInteger.Zero));`
`69`	`69`	`storage.Add(amount);`
`70`		`- engine.SendNotification(Hash, "Transfer", new Array { StackItem.Null, account.ToArray(), amount });`
	`70`	`+ PostTransfer(engine, null, account, amount);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`internal protected virtual void Burn(ApplicationEngine engine, UInt160 account, BigInteger amount)`
`@@ -85,7 +85,7 @@ internal protected virtual void Burn(ApplicationEngine engine, UInt160 account,`
`85`	`85`	`state.Balance -= amount;`
`86`	`86`	`storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_TotalSupply));`
`87`	`87`	`storage.Add(-amount);`
`88`		`- engine.SendNotification(Hash, "Transfer", new Array { account.ToArray(), StackItem.Null, amount });`
	`88`	`+ PostTransfer(engine, account, null, amount);`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`[ContractMethod(0_01000000, CallFlags.AllowStates)]`
`@@ -104,7 +104,7 @@ public virtual BigInteger BalanceOf(StoreView snapshot, UInt160 account)`
`104`	`104`	`return storage.GetInteroperable<TState>().Balance;`
`105`	`105`	`}`
`106`	`106`
`107`		`- [ContractMethod(0_08000000, CallFlags.AllowModifyStates)]`
	`107`	`+ [ContractMethod(0_09000000, CallFlags.AllowModifyStates)]`
`108`	`108`	`protected virtual bool Transfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount)`
`109`	`109`	`{`
`110`	`110`	`if (amount.Sign < 0) throw new ArgumentOutOfRangeException(nameof(amount));`
`@@ -143,12 +143,28 @@ protected virtual bool Transfer(ApplicationEngine engine, UInt160 from, UInt160`
`143`	`143`	`state_to.Balance += amount;`
`144`	`144`	`}`
`145`	`145`	`}`
`146`		`- engine.SendNotification(Hash, "Transfer", new Array { from.ToArray(), to.ToArray(), amount });`
	`146`	`+ PostTransfer(engine, from, to, amount);`
`147`	`147`	`return true;`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`protected virtual void OnBalanceChanging(ApplicationEngine engine, UInt160 account, TState state, BigInteger amount)`
`151`	`151`	`{`
`152`	`152`	`}`
	`153`	`+`
	`154`	`+ private void PostTransfer(ApplicationEngine engine, UInt160 from, UInt160 to, BigInteger amount)`
	`155`	`+ {`
	`156`	`+ // Send notification`
	`157`	`+`
	`158`	`+ engine.SendNotification(Hash, "Transfer",`
	`159`	`+ new Array { from?.ToArray() ?? StackItem.Null, to?.ToArray() ?? StackItem.Null, amount });`
	`160`	`+`
	`161`	`+ // Check if it's a wallet or smart contract`
	`162`	`+`
	`163`	`+ if (to is null \|\| engine.Snapshot.Contracts.TryGet(to) is null) return;`
	`164`	`+`
	`165`	`+ // Call onPayment method if exists (NEP-17)`
	`166`	`+`
	`167`	`+ engine.CallFromNativeContract(() => { }, to, "onPayment", from.ToArray(), amount);`
	`168`	`+ }`
`153`	`169`	`}`
`154`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public void TestDeserialize()`
`72`	`72`	`public void TestGetSize()`
`73`	`73`	`{`
`74`	`74`	`ISerializable newContract = contract;`
`75`		`- newContract.Size.Should().Be(218);`
	`75`	`+ newContract.Size.Should().Be(240);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`namespace Neo.UnitTests.SmartContract.Native.Tokens`
`10`	`10`	`{`
`11`	`11`	`[TestClass]`
`12`		`- public class UT_Nep5Token : TestKit`
	`12`	`+ public class UT_Nep17Token : TestKit`
`13`	`13`	`{`
`14`	`14`	`[TestInitialize]`
`15`	`15`	`public void TestSetup()`
`@@ -18,7 +18,13 @@ public void TestSetup()`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`protected const byte Prefix_TotalSupply = 11;`
`21`		`- private static readonly TestNep5Token test = new TestNep5Token();`
	`21`	`+ private static readonly TestNep17Token test = new TestNep17Token();`
	`22`	`+`
	`23`	`+ [TestMethod]`
	`24`	`+ public void TestName()`
	`25`	`+ {`
	`26`	`+ Assert.AreEqual(test.Name, test.Manifest.Name);`
	`27`	`+ }`
`22`	`28`
`23`	`29`	`[TestMethod]`
`24`	`30`	`public void TestTotalSupply()`
`@@ -71,11 +77,11 @@ public StorageKey CreateStorageKey(byte prefix, byte[] key = null)`
`71`	`77`	`}`
`72`	`78`	`}`
`73`	`79`
`74`		`- public class TestNep5Token : Nep5Token<NeoToken.NeoAccountState>`
	`80`	`+ public class TestNep17Token : Nep17Token<NeoToken.NeoAccountState>`
`75`	`81`	`{`
`76`	`82`	`public override int Id => 0x10000005;`
`77`	`83`
`78`		`- public override string Name => "testNep5Token";`
	`84`	`+ public override string Name => "testNep17Token";`
`79`	`85`
`80`	`86`	`public override string Symbol => throw new NotImplementedException();`
`81`	`87`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ public static ContractManifest CreateDefaultManifest(UInt160 hash)`
`22`	`22`	`{`
`23`	`23`	`return new ContractManifest()`
`24`	`24`	`{`
	`25`	`+ Name = "testManifest",`
`25`	`26`	`Groups = new ContractGroup[0],`
`26`	`27`	`SupportedStandards = Array.Empty<string>(),`
`27`	`28`	`Abi = new ContractAbi()`