BigInteger in Neo.Json

src/Neo.CLI/config.fs.mainnet.json

@@ -40,7 +40,8 @@
       "HF_Aspidochelone": 3000000,
       "HF_Basilisk": 4500000,
       "HF_Cockatrice": 5800000,
-      "HF_Domovoi": 5800000
+      "HF_Domovoi": 5800000,
+      "HF_Echidna": 5800001
     },
     "StandbyCommittee": [
       "026fa34ec057d74c2fdf1a18e336d0bd597ea401a0b2ad57340d5c220d09f44086",

src/Neo.CLI/config.json

@@ -38,7 +38,8 @@
       "HF_Aspidochelone": 1730000,
       "HF_Basilisk": 4120000,
       "HF_Cockatrice": 5450000,
-      "HF_Domovoi": 5570000
+      "HF_Domovoi": 5570000,
+      "HF_Echidna": 5570001
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo.CLI/config.mainnet.json

@@ -38,7 +38,8 @@
       "HF_Aspidochelone": 1730000,
       "HF_Basilisk": 4120000,
       "HF_Cockatrice": 5450000,
-      "HF_Domovoi": 5570000
+      "HF_Domovoi": 5570000,
+      "HF_Echidna": 5570001
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo.CLI/config.testnet.json

@@ -38,7 +38,8 @@
       "HF_Aspidochelone": 210000,
       "HF_Basilisk": 2680000,
       "HF_Cockatrice": 3967000,
-      "HF_Domovoi": 4144000
+      "HF_Domovoi": 4144000,
+      "HF_Echidna": 4144001
     },
     "InitialGasDistribution": 5200000000000000,
     "ValidatorsCount": 7,

src/Neo.Json/JNumber.cs

@@ -10,6 +10,7 @@
 // modifications are permitted.
 
 using System.Globalization;
+using System.Numerics;
 using System.Text.Json;
 
 namespace Neo.Json
@@ -38,9 +39,20 @@ public class JNumber : JToken
         /// Initializes a new instance of the <see cref="JNumber"/> class with the specified value.
         /// </summary>
         /// <param name="value">The value of the JSON token.</param>
-        public JNumber(double value = 0)
+        /// <param name="checkMinMax">True if we want to ensure that the value is in the limits.</param>
+        public JNumber(double value = 0, bool checkMinMax = true)
         {
-            if (!double.IsFinite(value)) throw new FormatException();
+            if (checkMinMax)
+            {
+                if (value > MAX_SAFE_INTEGER)
+                    throw new ArgumentException("value is higher than MAX_SAFE_INTEGER", nameof(value));
+                if (value < MIN_SAFE_INTEGER)
+                    throw new ArgumentException("value is lower than MIN_SAFE_INTEGER", nameof(value));
+            }
+
+            if (!double.IsFinite(value))
+                throw new ArgumentException("value is not finite", nameof(value));
+
             Value = value;
         }
 
@@ -125,6 +137,22 @@ public static implicit operator JNumber(long value)
             return new JNumber(value);
         }
 
+        public static implicit operator JNumber(BigInteger value)
+        {
+            return new JNumber((long)value);
+        }
+
+        /// <summary>
+        /// Check if two JNumber are equal.
+        /// </summary>
+        /// <param name="left">Non null <see cref="JNumber"></see> value </param>
+        /// <param name="right">Nullable <see cref="JNumber"></see> value</param>
+        /// <returns>bool</returns>
+        /// <remarks>
+        /// If the left is null, throw an <exception cref="NullReferenceException"></exception>.
+        /// If the right is null, return false.
+        /// If the left and right are the same object, return true.
+        /// </remarks>
         public static bool operator ==(JNumber left, JNumber? right)
         {
             if (right is null) return false;

src/Neo.Json/JToken.cs

@@ -9,6 +9,7 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
+using System.Numerics;
 using System.Text.Json;
 using static Neo.Json.Utility;
 
@@ -295,10 +296,15 @@ public static implicit operator JToken(JToken?[] value)
 
         public static implicit operator JToken(bool value)
         {
-            return (JBoolean)value;
+            return new JBoolean(value);
         }
 
         public static implicit operator JToken(double value)
+        {
+            return new JNumber(value);
+        }
+
+        public static implicit operator JToken(BigInteger value)
         {
             return (JNumber)value;
         }

src/Neo/Hardfork.cs

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

src/Neo/Neo.csproj

@@ -16,6 +16,8 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.2" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
+    <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="8.0.1" />
+    <PackageReference Include="System.IO.Hashing" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Neo/SmartContract/JsonSerializer.cs

@@ -35,14 +35,15 @@ public static class JsonSerializer
         /// Serializes a <see cref="StackItem"/> to a <see cref="JToken"/>.
         /// </summary>
         /// <param name="item">The <see cref="StackItem"/> to serialize.</param>
+        /// <param name="hardforkChecker">Hardfork checker</param>
         /// <returns>The serialized object.</returns>
-        public static JToken Serialize(StackItem item)
+        public static JToken Serialize(StackItem item, Func<Hardfork, bool> hardforkChecker = null)
         {
             switch (item)
             {
                 case Array array:
                     {
-                        return array.Select(p => Serialize(p)).ToArray();
+                        return array.Select(p => Serialize(p, hardforkChecker)).ToArray();
                     }
                 case ByteString _:
                 case Buffer _:
@@ -51,10 +52,7 @@ public static JToken Serialize(StackItem item)
                     }
                 case Integer num:
                     {
-                        var integer = num.GetInteger();
-                        if (integer > JNumber.MAX_SAFE_INTEGER || integer < JNumber.MIN_SAFE_INTEGER)
-                            throw new InvalidOperationException();
-                        return (double)integer;
+                        return new JNumber((long)num.GetInteger(), hardforkChecker == null || hardforkChecker(Hardfork.HF_Echidna));
                     }
                 case Boolean boolean:
                     {
@@ -66,10 +64,10 @@ public static JToken Serialize(StackItem item)
 
                         foreach (var entry in map)
                         {
-                            if (!(entry.Key is ByteString)) throw new FormatException();
+                            if (entry.Key is not ByteString) throw new FormatException();
 
                             var key = entry.Key.GetString();
-                            var value = Serialize(entry.Value);
+                            var value = Serialize(entry.Value, hardforkChecker);
 
                             ret[key] = value;
                         }

src/Neo/SmartContract/Native/RoleManagement.cs

@@ -26,7 +26,16 @@ public sealed class RoleManagement : NativeContract
     {
         [ContractEvent(0, name: "Designation",
             "Role", ContractParameterType.Integer,
-            "BlockIndex", ContractParameterType.Integer)]
+            "BlockIndex", ContractParameterType.Integer,
+            Hardfork.HF_Echidna)]
+
+        [ContractEvent(Hardfork.HF_Echidna, 0, name: "Designation",
+            "Role", ContractParameterType.Integer,
+            "BlockIndex", ContractParameterType.Integer,
+            "Old", ContractParameterType.Array,
+            "New", ContractParameterType.Array
+            )]
+
         internal RoleManagement() : base() { }
 
         /// <summary>
@@ -51,6 +60,7 @@ public ECPoint[] GetDesignatedByRole(DataCache snapshot, Role role, uint index)
         }
 
         [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
+        [Obsolete]
         private void DesignateAsRole(ApplicationEngine engine, Role role, ECPoint[] nodes)
         {
             if (nodes.Length == 0 || nodes.Length > 32)
@@ -69,7 +79,17 @@ private void DesignateAsRole(ApplicationEngine engine, Role role, ECPoint[] node
             list.AddRange(nodes);
             list.Sort();
             engine.SnapshotCache.Add(key, new StorageItem(list));
-            engine.SendNotification(Hash, "Designation", new VM.Types.Array(engine.ReferenceCounter, new StackItem[] { (int)role, engine.PersistingBlock.Index }));
+            if (engine.IsHardforkEnabled(Hardfork.HF_Echidna))
+            {
+                var oldNodes = new VM.Types.Array(engine.ReferenceCounter, GetDesignatedByRole(engine.Snapshot, role, index - 1).Select(u => (ByteString)u.EncodePoint(true)));
+                var newNodes = new VM.Types.Array(engine.ReferenceCounter, nodes.Select(u => (ByteString)u.EncodePoint(true)));
+
+                engine.SendNotification(Hash, "Designation", new VM.Types.Array(engine.ReferenceCounter, [(int)role, engine.PersistingBlock.Index, oldNodes, newNodes]));
+            }
+            else
+            {
+                engine.SendNotification(Hash, "Designation", new VM.Types.Array(engine.ReferenceCounter, [(int)role, engine.PersistingBlock.Index]));
+            }
         }
 
         private class NodeList : InteroperableList<ECPoint>

src/Neo/SmartContract/Native/StdLib.cs

@@ -11,6 +11,7 @@
 
 #pragma warning disable IDE0051
 
+using Microsoft.IdentityModel.Tokens;
 using Neo.Cryptography;
 using Neo.Json;
 using Neo.VM.Types;
@@ -131,6 +132,28 @@ public static byte[] Base64Decode([MaxLength(MaxInputLength)] string s)
             return Convert.FromBase64String(s);
         }
 
+        /// <summary>
+        /// Encodes a byte array into a base64Url string.
+        /// </summary>
+        /// <param name="data">The base64Url to be encoded.</param>
+        /// <returns>The encoded base64Url string.</returns>
+        [ContractMethod(Hardfork.HF_Echidna, CpuFee = 1 << 5)]
+        public static string Base64UrlEncode([MaxLength(MaxInputLength)] string data)
+        {
+            return Base64UrlEncoder.Encode(data);
+        }
+
+        /// <summary>
+        /// Decodes a byte array from a base64Url string.
+        /// </summary>
+        /// <param name="s">The base64Url string.</param>
+        /// <returns>The decoded base64Url string.</returns>
+        [ContractMethod(Hardfork.HF_Echidna, CpuFee = 1 << 5)]
+        public static string Base64UrlDecode([MaxLength(MaxInputLength)] string s)
+        {
+            return Base64UrlEncoder.Decode(s);
+        }
+
         /// <summary>
         /// Encodes a byte array into a base58 <see cref="string"/>.
         /// </summary>

tests/Neo.Json.UnitTests/UT_JNumber.cs

@@ -39,20 +39,47 @@ public void SetUp()
         public void TestAsBoolean()
         {
             maxInt.AsBoolean().Should().BeTrue();
+            minInt.AsBoolean().Should().BeTrue();
             zero.AsBoolean().Should().BeFalse();
         }
 
+        [TestMethod]
+        public void TestBigInteger()
+        {
+            ((JNumber)BigInteger.One).AsNumber().Should().Be(1);
+            ((JNumber)BigInteger.Zero).AsNumber().Should().Be(0);
+            ((JNumber)BigInteger.MinusOne).AsNumber().Should().Be(-1);
+            ((JNumber)JNumber.MAX_SAFE_INTEGER).AsNumber().Should().Be(JNumber.MAX_SAFE_INTEGER);
+            ((JNumber)JNumber.MIN_SAFE_INTEGER).AsNumber().Should().Be(JNumber.MIN_SAFE_INTEGER);
+        }
+
+        [TestMethod]
+        public void TestNullEqual()
+        {
+            JNumber nullJNumber = null;
+
+            Assert.IsFalse(maxInt.Equals(null));
+            Assert.IsFalse(maxInt == null);
+            Assert.IsFalse(minInt.Equals(null));
+            Assert.IsFalse(minInt == null);
+            Assert.IsFalse(zero == null);
+
+            Assert.ThrowsException<NullReferenceException>(() => nullJNumber == maxInt);
+            Assert.ThrowsException<NullReferenceException>(() => nullJNumber == minInt);
+            Assert.ThrowsException<NullReferenceException>(() => nullJNumber == zero);
+        }
+
         [TestMethod]
         public void TestAsString()
         {
             Action action1 = () => new JNumber(double.PositiveInfinity).AsString();
-            action1.Should().Throw<FormatException>();
+            action1.Should().Throw<ArgumentException>();
 
             Action action2 = () => new JNumber(double.NegativeInfinity).AsString();
-            action2.Should().Throw<FormatException>();
+            action2.Should().Throw<ArgumentException>();
 
             Action action3 = () => new JNumber(double.NaN).AsString();
-            action3.Should().Throw<FormatException>();
+            action3.Should().Throw<ArgumentException>();
         }
 
         [TestMethod]