Allow Native Contracts to be updated

src/Neo/Neo.csproj

@@ -13,7 +13,7 @@
     <PackageReference Include="Akka" Version="1.5.12" />
     <PackageReference Include="BouncyCastle.NetCore" Version="2.2.1" />
     <PackageReference Include="K4os.Compression.LZ4" Version="1.3.6" />
-    <PackageReference Include="Neo.VM" Version="3.6.0" />
+    <PackageReference Include="Neo.VM" Version="3.6.0-CI00334" />
     <PackageReference Include="Neo.Cryptography.BLS12_381" Version="0.2.0" />
   </ItemGroup>
 

src/Neo/ProtocolSettings.cs

@@ -23,6 +23,8 @@ namespace Neo
     /// </summary>
     public record ProtocolSettings
     {
+        private static readonly IList<Hardfork> AllHardforks = Enum.GetValues(typeof(Hardfork)).Cast<Hardfork>().ToArray();
+
         /// <summary>
         /// The magic number of the NEO network.
         /// </summary>
@@ -146,7 +148,7 @@ public record ProtocolSettings
             MemoryPoolMaxTransactions = 50_000,
             MaxTraceableBlocks = 2_102_400,
             InitialGasDistribution = 52_000_000_00000000,
-            Hardforks = ImmutableDictionary<Hardfork, uint>.Empty
+            Hardforks = EnsureOmmitedHardforks(new Dictionary<Hardfork, uint>()).ToImmutableDictionary()
         };
 
         /// <summary>
@@ -188,17 +190,39 @@ public static ProtocolSettings Load(IConfigurationSection section)
                 MaxTraceableBlocks = section.GetValue("MaxTraceableBlocks", Default.MaxTraceableBlocks),
                 InitialGasDistribution = section.GetValue("InitialGasDistribution", Default.InitialGasDistribution),
                 Hardforks = section.GetSection("Hardforks").Exists()
-                    ? section.GetSection("Hardforks").GetChildren().ToImmutableDictionary(p => Enum.Parse<Hardfork>(p.Key), p => uint.Parse(p.Value))
+                    ? EnsureOmmitedHardforks(section.GetSection("Hardforks").GetChildren().ToDictionary(p => Enum.Parse<Hardfork>(p.Key, true), p => uint.Parse(p.Value))).ToImmutableDictionary()
                     : Default.Hardforks
             };
         }
 
+        /// <summary>
+        /// Explicitly set the height of all old omitted hardforks to 0 for proper IsHardforkEnabled behaviour.
+        /// </summary>
+        /// <param name="hardForks">HardForks</param>
+        /// <returns>Processed hardfork configuration</returns>
+        private static Dictionary<Hardfork, uint> EnsureOmmitedHardforks(Dictionary<Hardfork, uint> hardForks)
+        {
+            foreach (Hardfork hf in AllHardforks)
+            {
+                if (!hardForks.ContainsKey(hf))
+                {
+                    hardForks[hf] = 0;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return hardForks;
+        }
+
         private static void CheckingHardfork(ProtocolSettings settings)
         {
             var allHardforks = Enum.GetValues(typeof(Hardfork)).Cast<Hardfork>().ToList();
             // Check for continuity in configured hardforks
             var sortedHardforks = settings.Hardforks.Keys
-                .OrderBy(h => allHardforks.IndexOf(h))
+                .OrderBy(allHardforks.IndexOf)
                 .ToList();
 
             for (int i = 0; i < sortedHardforks.Count - 1; i++)
@@ -208,17 +232,35 @@ private static void CheckingHardfork(ProtocolSettings settings)
 
                 // If they aren't consecutive, return false.
                 if (nextIndex - currentIndex > 1)
-                    throw new Exception("Hardfork configuration is not continuous.");
+                    throw new ArgumentException("Hardfork configuration is not continuous.");
             }
             // Check that block numbers are not higher in earlier hardforks than in later ones
             for (int i = 0; i < sortedHardforks.Count - 1; i++)
             {
                 if (settings.Hardforks[sortedHardforks[i]] > settings.Hardforks[sortedHardforks[i + 1]])
                 {
                     // This means the block number for the current hardfork is greater than the next one, which should not be allowed.
-                    throw new Exception($"The Hardfork configuration for {sortedHardforks[i]} is greater than for {sortedHardforks[i + 1]}");
+                    throw new ArgumentException($"The Hardfork configuration for {sortedHardforks[i]} is greater than for {sortedHardforks[i + 1]}");
                 }
             }
         }
+
+        /// <summary>
+        /// Check if the Hardfork is Enabled
+        /// </summary>
+        /// <param name="hardfork">Hardfork</param>
+        /// <param name="index">Block index</param>
+        /// <returns>True if enabled</returns>
+        public bool IsHardforkEnabled(Hardfork hardfork, uint index)
+        {
+            if (Hardforks.TryGetValue(hardfork, out uint height))
+            {
+                // If the hardfork has a specific height in the configuration, check the block height.
+                return index >= height;
+            }
+
+            // If the hardfork isn't specified in the configuration, return false.
+            return false;
+        }
     }
 }

src/Neo/SmartContract/ApplicationEngine.cs

@@ -46,7 +46,6 @@ public partial class ApplicationEngine : ExecutionEngine
         /// </summary>
         public static event EventHandler<LogEventArgs> Log;
 
-        private static readonly IList<Hardfork> AllHardforks = Enum.GetValues(typeof(Hardfork)).Cast<Hardfork>().ToArray();
         private static Dictionary<uint, InteropDescriptor> services;
         private readonly long gas_amount;
         private Dictionary<Type, object> states;
@@ -605,6 +604,25 @@ public T GetState<T>()
             return (T)state;
         }
 
+        public T GetState<T>(Func<T> factory)
+        {
+            if (states is null)
+            {
+                T state = factory();
+                SetState(state);
+                return state;
+            }
+            else
+            {
+                if (!states.TryGetValue(typeof(T), out object state))
+                {
+                    state = factory();
+                    SetState(state);
+                }
+                return (T)state;
+            }
+        }
+
         public void SetState<T>(T state)
         {
             states ??= new Dictionary<Type, object>();
@@ -613,28 +631,11 @@ public void SetState<T>(T state)
 
         public bool IsHardforkEnabled(Hardfork hardfork)
         {
-            // Return true if there's no specific configuration or PersistingBlock is null
-            if (PersistingBlock is null || ProtocolSettings.Hardforks.Count == 0)
+            // Return true if PersistingBlock is null
+            if (PersistingBlock is null)
                 return true;
 
-            // If the hardfork isn't specified in the configuration, check if it's a new one.
-            if (!ProtocolSettings.Hardforks.ContainsKey(hardfork))
-            {
-                int currentHardforkIndex = AllHardforks.IndexOf(hardfork);
-                int lastConfiguredHardforkIndex = AllHardforks.IndexOf(ProtocolSettings.Hardforks.Keys.Last());
-
-                // If it's a newer hardfork compared to the ones in the configuration, disable it.
-                if (currentHardforkIndex > lastConfiguredHardforkIndex)
-                    return false;
-            }
-
-            if (ProtocolSettings.Hardforks.TryGetValue(hardfork, out uint height))
-            {
-                // If the hardfork has a specific height in the configuration, check the block height.
-                return PersistingBlock.Index >= height;
-            }
-            // If no specific conditions are met, return true.
-            return true;
+            return ProtocolSettings.IsHardforkEnabled(hardfork, PersistingBlock.Index);
         }
     }
 }

src/Neo/SmartContract/Native/ContractEventAttribute.cs

@@ -0,0 +1,164 @@
+// Copyright (C) 2015-2023 The Neo Project.
+// 
+// The neo is free software distributed under the MIT software license, 
+// see the accompanying file LICENSE in the main directory of the
+// project or http://www.opensource.org/licenses/mit-license.php 
+// for more details.
+// 
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.Diagnostics;
+using Neo.SmartContract.Manifest;
+
+namespace Neo.SmartContract.Native
+{
+    [DebuggerDisplay("{Descriptor.Name}")]
+    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = true)]
+    internal class ContractEventAttribute : Attribute
+    {
+        public int Order { get; init; }
+        public ContractEventDescriptor Descriptor { get; set; }
+        public Hardfork? ActiveIn { get; init; } = null;
+
+        public ContractEventAttribute(Hardfork activeIn, int order, string name,
+            string arg1Name, ContractParameterType arg1Value) : this(order, name, arg1Name, arg1Value)
+        {
+            ActiveIn = activeIn;
+        }
+
+        public ContractEventAttribute(int order, string name, string arg1Name, ContractParameterType arg1Value)
+        {
+            Order = order;
+            Descriptor = new ContractEventDescriptor()
+            {
+                Name = name,
+                Parameters = new ContractParameterDefinition[]
+                {
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg1Name,
+                        Type = arg1Value
+                    }
+                }
+            };
+        }
+
+        public ContractEventAttribute(Hardfork activeIn, int order, string name,
+            string arg1Name, ContractParameterType arg1Value,
+            string arg2Name, ContractParameterType arg2Value) : this(order, name, arg1Name, arg1Value, arg2Name, arg2Value)
+        {
+            ActiveIn = activeIn;
+        }
+
+        public ContractEventAttribute(int order, string name,
+            string arg1Name, ContractParameterType arg1Value,
+            string arg2Name, ContractParameterType arg2Value)
+        {
+            Order = order;
+            Descriptor = new ContractEventDescriptor()
+            {
+                Name = name,
+                Parameters = new ContractParameterDefinition[]
+                {
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg1Name,
+                        Type = arg1Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg2Name,
+                        Type = arg2Value
+                    }
+                }
+            };
+        }
+
+        public ContractEventAttribute(Hardfork activeIn, int order, string name,
+            string arg1Name, ContractParameterType arg1Value,
+            string arg2Name, ContractParameterType arg2Value,
+            string arg3Name, ContractParameterType arg3Value) : this(order, name, arg1Name, arg1Value, arg2Name, arg2Value, arg3Name, arg3Value)
+        {
+            ActiveIn = activeIn;
+        }
+
+        public ContractEventAttribute(int order, string name,
+           string arg1Name, ContractParameterType arg1Value,
+           string arg2Name, ContractParameterType arg2Value,
+           string arg3Name, ContractParameterType arg3Value
+           )
+        {
+            Order = order;
+            Descriptor = new ContractEventDescriptor()
+            {
+                Name = name,
+                Parameters = new ContractParameterDefinition[]
+                {
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg1Name,
+                        Type = arg1Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg2Name,
+                        Type = arg2Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg3Name,
+                        Type = arg3Value
+                    }
+                }
+            };
+        }
+
+        public ContractEventAttribute(Hardfork activeIn, int order, string name,
+            string arg1Name, ContractParameterType arg1Value,
+            string arg2Name, ContractParameterType arg2Value,
+            string arg3Name, ContractParameterType arg3Value,
+            string arg4Name, ContractParameterType arg4Value) : this(order, name, arg1Name, arg1Value, arg2Name, arg2Value, arg3Name, arg3Value, arg4Name, arg4Value)
+        {
+            ActiveIn = activeIn;
+        }
+
+        public ContractEventAttribute(int order, string name,
+            string arg1Name, ContractParameterType arg1Value,
+            string arg2Name, ContractParameterType arg2Value,
+            string arg3Name, ContractParameterType arg3Value,
+            string arg4Name, ContractParameterType arg4Value
+            )
+        {
+            Order = order;
+            Descriptor = new ContractEventDescriptor()
+            {
+                Name = name,
+                Parameters = new ContractParameterDefinition[]
+                {
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg1Name,
+                        Type = arg1Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg2Name,
+                        Type = arg2Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg3Name,
+                        Type = arg3Value
+                    },
+                    new ContractParameterDefinition()
+                    {
+                        Name = arg4Name,
+                        Type = arg4Value
+                    }
+                }
+            };
+        }
+    }
+}