v3.7.5

.github/workflows/main.yml

@@ -2,7 +2,7 @@ name: .NET Core Test and Publish
 
 on:
   push:
-    branches: [master]
+    branches: [v3.7.5]
   pull_request:
 
 env:

benchmarks/Neo.Benchmarks/Neo.Benchmarks.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net8.0</TargetFrameworks>
+    <TargetFramework>net8.0</TargetFramework>
     <RootNamespace>Neo</RootNamespace>
     <ImplicitUsings>enable</ImplicitUsings>
     <IsPackable>false</IsPackable>

benchmarks/Neo.VM.Benchmarks/Neo.VM.Benchmarks.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net8.0</TargetFrameworks>
+    <TargetFramework>net8.0</TargetFramework>
     <RootNamespace>Neo.VM</RootNamespace>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>

src/Directory.Build.props

@@ -3,7 +3,7 @@
 
   <PropertyGroup>
     <Copyright>2015-2024 The Neo Project</Copyright>
-    <VersionPrefix>3.7.4</VersionPrefix>
+    <VersionPrefix>3.7.5</VersionPrefix>
     <LangVersion>12.0</LangVersion>
     <Authors>The Neo Project</Authors>
     <PackageIcon>neo.png</PackageIcon>

src/Neo.CLI/config.json

@@ -37,7 +37,8 @@
     "Hardforks": {
       "HF_Aspidochelone": 1730000,
       "HF_Basilisk": 4120000,
-      "HF_Cockatrice": 5450000
+      "HF_Cockatrice": 5450000,
+      "HF_Domovoi": 5570000
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo.CLI/config.mainnet.json

@@ -37,7 +37,8 @@
     "Hardforks": {
       "HF_Aspidochelone": 1730000,
       "HF_Basilisk": 4120000,
-      "HF_Cockatrice": 5450000
+      "HF_Cockatrice": 5450000,
+      "HF_Domovoi": 5570000
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo.CLI/config.testnet.json

@@ -37,7 +37,8 @@
     "Hardforks": {
       "HF_Aspidochelone": 210000,
       "HF_Basilisk": 2680000,
-      "HF_Cockatrice": 3967000
+      "HF_Cockatrice": 3967000,
+      "HF_Domovoi": 4144000
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo/Hardfork.cs

@@ -15,6 +15,7 @@ public enum Hardfork : byte
     {
         HF_Aspidochelone,
         HF_Basilisk,
-        HF_Cockatrice
+        HF_Cockatrice,
+        HF_Domovoi
     }
 }

src/Neo/SmartContract/ApplicationEngine.Runtime.cs

@@ -406,14 +406,19 @@ protected internal void SendNotification(UInt160 hash, string eventName, Array s
         /// </summary>
         /// <param name="hash">The hash of the specified contract. It can be set to <see langword="null"/> to get all notifications.</param>
         /// <returns>The notifications sent during the execution.</returns>
-        protected internal NotifyEventArgs[] GetNotifications(UInt160 hash)
+        protected internal Array GetNotifications(UInt160 hash)
         {
             IEnumerable<NotifyEventArgs> notifications = Notifications;
             if (hash != null) // must filter by scriptHash
                 notifications = notifications.Where(p => p.ScriptHash == hash);
-            NotifyEventArgs[] array = notifications.ToArray();
+            var array = notifications.ToArray();
             if (array.Length > Limits.MaxStackSize) throw new InvalidOperationException();
-            return array;
+            Array notifyArray = new(ReferenceCounter);
+            foreach (var notify in array)
+            {
+                notifyArray.Add(notify.ToStackItem(ReferenceCounter, this));
+            }
+            return notifyArray;
         }
 
         /// <summary>

src/Neo/SmartContract/ApplicationEngine.cs

@@ -271,14 +271,18 @@ private ExecutionContext CallContractInternal(ContractState contract, ContractMe
             if (NativeContract.Policy.IsBlocked(Snapshot, contract.Hash))
                 throw new InvalidOperationException($"The contract {contract.Hash} has been blocked.");
 
+            ExecutionContext currentContext = CurrentContext;
+            ExecutionContextState state = currentContext.GetState<ExecutionContextState>();
             if (method.Safe)
             {
                 flags &= ~(CallFlags.WriteStates | CallFlags.AllowNotify);
             }
             else
             {
-                ContractState currentContract = NativeContract.ContractManagement.GetContract(Snapshot, CurrentScriptHash);
-                if (currentContract?.CanCall(contract, method.Name) == false)
+                var executingContract = IsHardforkEnabled(Hardfork.HF_Domovoi)
+                ? state.Contract // use executing contract state to avoid possible contract update/destroy side-effects, ref. /~https://github.com/neo-project/neo/pull/3290.
+                : NativeContract.ContractManagement.GetContract(Snapshot, CurrentScriptHash);
+                if (executingContract?.CanCall(contract, method.Name) == false)
                     throw new InvalidOperationException($"Cannot Call Method {method.Name} Of Contract {contract.Hash} From Contract {CurrentScriptHash}");
             }
 
@@ -291,8 +295,6 @@ private ExecutionContext CallContractInternal(ContractState contract, ContractMe
                 invocationCounter[contract.Hash] = 1;
             }
 
-            ExecutionContext currentContext = CurrentContext;
-            ExecutionContextState state = currentContext.GetState<ExecutionContextState>();
             CallFlags callingFlags = state.CallFlags;
 
             if (args.Count != method.Parameters.Length) throw new InvalidOperationException($"Method {method} Expects {method.Parameters.Length} Arguments But Receives {args.Count} Arguments");

src/Neo/SmartContract/NotifyEventArgs.cs

@@ -66,11 +66,31 @@ public void FromStackItem(StackItem stackItem)
         public StackItem ToStackItem(ReferenceCounter referenceCounter)
         {
             return new Array(referenceCounter)
+                {
+                    ScriptHash.ToArray(),
+                    EventName,
+                    State
+                };
+        }
+
+        public StackItem ToStackItem(ReferenceCounter referenceCounter, ApplicationEngine engine)
+        {
+            if (engine.IsHardforkEnabled(Hardfork.HF_Domovoi))
             {
-                ScriptHash.ToArray(),
-                EventName,
-                State
-            };
+                return new Array(referenceCounter)
+                {
+                    ScriptHash.ToArray(),
+                    EventName,
+                    State.OnStack ? State : State.DeepCopy(true)
+                };
+            }
+
+            return new Array(referenceCounter)
+                {
+                    ScriptHash.ToArray(),
+                    EventName,
+                    State
+                };
         }
     }
 }

tests/Neo.UnitTests/SmartContract/UT_ApplicationEngine.cs

@@ -12,6 +12,9 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using Neo.UnitTests.Extensions;
+using Neo.VM;
 using System;
 using System.Collections.Immutable;
 using System.Linq;
@@ -103,5 +106,103 @@ public void TestCheckingHardfork()
                 (setting[sortedHardforks[i]] > setting[sortedHardforks[i + 1]]).Should().Be(false);
             }
         }
+
+        [TestMethod]
+        public void TestSystem_Contract_Call_Permissions()
+        {
+            UInt160 scriptHash;
+            var snapshot = TestBlockchain.GetTestSnapshot();
+
+            // Setup: put a simple contract to the storage.
+            using (var script = new ScriptBuilder())
+            {
+                // Push True on stack and return.
+                script.EmitPush(true);
+                script.Emit(OpCode.RET);
+
+                // Mock contract and put it to the Managemant's storage.
+                scriptHash = script.ToArray().ToScriptHash();
+
+                snapshot.DeleteContract(scriptHash);
+                var contract = TestUtils.GetContract(script.ToArray(), TestUtils.CreateManifest("test", ContractParameterType.Any));
+                contract.Manifest.Abi.Methods = new[]
+                {
+                    new ContractMethodDescriptor
+                    {
+                        Name = "disallowed",
+                        Parameters = new ContractParameterDefinition[]{}
+                    },
+                    new ContractMethodDescriptor
+                    {
+                        Name = "test",
+                        Parameters = new ContractParameterDefinition[]{}
+                    }
+                };
+                snapshot.AddContract(scriptHash, contract);
+            }
+
+            // Disallowed method call.
+            using (var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, null, ProtocolSettings.Default))
+            using (var script = new ScriptBuilder())
+            {
+                // Build call script calling disallowed method.
+                script.EmitDynamicCall(scriptHash, "disallowed");
+
+                // Mock executing state to be a contract-based.
+                engine.LoadScript(script.ToArray());
+                engine.CurrentContext.GetState<ExecutionContextState>().Contract = new()
+                {
+                    Manifest = new()
+                    {
+                        Abi = new() { },
+                        Permissions = new ContractPermission[]
+                        {
+                            new ContractPermission
+                            {
+                                Contract = ContractPermissionDescriptor.Create(scriptHash),
+                                Methods = WildcardContainer<string>.Create(new string[]{"test"}) // allowed to call only "test" method of the target contract.
+                            }
+                        }
+                    }
+                };
+                var currentScriptHash = engine.EntryScriptHash;
+
+                Assert.AreEqual(VMState.FAULT, engine.Execute());
+                Assert.IsTrue(engine.FaultException.ToString().Contains($"Cannot Call Method disallowed Of Contract {scriptHash.ToString()}"));
+            }
+
+            // Allowed method call.
+            using (var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, null, ProtocolSettings.Default))
+            using (var script = new ScriptBuilder())
+            {
+                // Build call script.
+                script.EmitDynamicCall(scriptHash, "test");
+
+                // Mock executing state to be a contract-based.
+                engine.LoadScript(script.ToArray());
+                engine.CurrentContext.GetState<ExecutionContextState>().Contract = new()
+                {
+                    Manifest = new()
+                    {
+                        Abi = new() { },
+                        Permissions = new ContractPermission[]
+                        {
+                            new ContractPermission
+                            {
+                                Contract = ContractPermissionDescriptor.Create(scriptHash),
+                                Methods = WildcardContainer<string>.Create(new string[]{"test"}) // allowed to call only "test" method of the target contract.
+                            }
+                        }
+                    }
+                };
+                var currentScriptHash = engine.EntryScriptHash;
+
+                Assert.AreEqual(VMState.HALT, engine.Execute());
+                Assert.AreEqual(1, engine.ResultStack.Count);
+                Assert.IsInstanceOfType(engine.ResultStack.Peek(), typeof(VM.Types.Boolean));
+                var res = (VM.Types.Boolean)engine.ResultStack.Pop();
+                Assert.IsTrue(res.GetBoolean());
+            }
+        }
     }
 }

tests/Neo.UnitTests/SmartContract/UT_InteropService.cs

@@ -71,6 +71,14 @@ public void Runtime_GetNotifications_Test()
                         }
                     }
                 };
+                contract.Manifest.Permissions = new ContractPermission[]
+                {
+                    new ContractPermission
+                    {
+                        Contract = ContractPermissionDescriptor.Create(scriptHash2),
+                        Methods = WildcardContainer<string>.Create(new string[]{"test"})
+                    }
+                };
                 snapshot.AddContract(scriptHash2, contract);
             }
 
@@ -133,6 +141,14 @@ public void Runtime_GetNotifications_Test()
                                     Parameters = System.Array.Empty<ContractParameterDefinition>()
                                 }
                             }
+                        },
+                        Permissions = new ContractPermission[]
+                        {
+                            new ContractPermission
+                            {
+                                Contract = ContractPermissionDescriptor.Create(scriptHash2),
+                                Methods = WildcardContainer<string>.Create(new string[]{"test"})
+                            }
                         }
                     }
                 };
@@ -202,6 +218,14 @@ public void Runtime_GetNotifications_Test()
                                     Parameters = System.Array.Empty<ContractParameterDefinition>()
                                 }
                             }
+                        },
+                        Permissions = new ContractPermission[]
+                        {
+                            new ContractPermission
+                            {
+                                Contract = ContractPermissionDescriptor.Create(scriptHash2),
+                                Methods = WildcardContainer<string>.Create(new string[]{"test"})
+                            }
                         }
                     }
                 };
@@ -642,7 +666,7 @@ public void TestContract_Call()
             var args = new VM.Types.Array { 0, 1 };
             var state = TestUtils.GetContract(method, args.Count);
 
-            var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot);
+            var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, null, ProtocolSettings.Default);
             engine.LoadScript(new byte[] { 0x01 });
             engine.Snapshot.AddContract(state.Hash, state);
 

tests/Neo.UnitTests/SmartContract/UT_NotifyEventArgs.cs

@@ -13,6 +13,8 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.Network.P2P.Payloads;
 using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
 
 namespace Neo.UnitTests.SmartContract
 {
@@ -27,5 +29,37 @@ public void TestGetScriptContainer()
             NotifyEventArgs args = new NotifyEventArgs(container, script_hash, "Test", null);
             args.ScriptContainer.Should().Be(container);
         }
+
+
+        [TestMethod]
+        public void TestIssue3300() // /~https://github.com/neo-project/neo/issues/3300
+        {
+            using var engine = ApplicationEngine.Create(TriggerType.Application, null, null, settings: TestProtocolSettings.Default, gas: 1100_00000000);
+            using (var script = new ScriptBuilder())
+            {
+                // Build call script calling disallowed method.
+                script.Emit(OpCode.NOP);
+                // Mock executing state to be a contract-based.
+                engine.LoadScript(script.ToArray());
+            }
+
+            var ns = new Array(engine.ReferenceCounter);
+            for (var i = 0; i < 500; i++)
+            {
+                ns.Add("");
+            };
+
+            var hash = UInt160.Parse("0x179ab5d297fd34ecd48643894242fc3527f42853");
+            engine.SendNotification(hash, "Test", ns);
+            // This should have being 0, but we have optimized the vm to not clean the reference counter
+            // unless it is necessary, so the reference counter will be 1000.
+            // Same reason why its 1504 instead of 504.
+            Assert.AreEqual(1000, engine.ReferenceCounter.Count);
+            // This will make a deepcopy for the notification, along with the 500 state items.
+            engine.GetNotifications(hash);
+            // With the fix of issue 3300, the reference counter calculates not only
+            // the notifaction items, but also the subitems of the notification state.
+            Assert.AreEqual(1504, engine.ReferenceCounter.Count);
+        }
     }
 }

tests/Neo.UnitTests/SmartContract/UT_Syscalls.cs

@@ -257,7 +257,7 @@ public void System_Runtime_GetInvocationCounter()
 
                 // Execute
 
-                var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot);
+                var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, null, ProtocolSettings.Default);
                 engine.LoadScript(script.ToArray());
                 Assert.AreEqual(VMState.HALT, engine.Execute());