[Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of unsafe

.gitignore

@@ -257,6 +257,8 @@ paket-files/
 PublishProfiles
 /.vscode
 launchSettings.json
+/coverages
+**/.DS_Store
 
 # Benchmarks
-**/BenchmarkDotNet.Artifacts/
+**/BenchmarkDotNet.Artifacts/

src/Neo.VM/Types/ByteString.cs

@@ -80,7 +80,7 @@ internal bool Equals(StackItem? other, ref uint limits)
         public override bool GetBoolean()
         {
             if (Size > Integer.MaxSize) throw new InvalidCastException();
-            return Unsafe.NotZero(GetSpan());
+            return GetSpan().NotZero();
         }
 
         public override BigInteger GetInteger()

src/Neo.VM/Unsafe.cs

@@ -19,9 +19,17 @@ unsafe internal static class Unsafe
     {
         private const long DefaultXxHash3Seed = 40343;
 
+        /// <summary>
+        /// All bytes are zero or not in a byte array
+        /// </summary>
+        /// <param name="x">The byte array</param>
+        /// <returns>false if all bytes are zero, true otherwise</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool NotZero(ReadOnlySpan<byte> x)
+        public static bool NotZero(this ReadOnlySpan<byte> x)
         {
+#if NET7_0_OR_GREATER
+            return x.IndexOfAnyExcept((byte)0) >= 0;
+#else
             int len = x.Length;
             if (len == 0) return false;
             fixed (byte* xp = x)
@@ -40,6 +48,7 @@ public static bool NotZero(ReadOnlySpan<byte> x)
                 }
             }
             return false;
+#endif
         }
 
         /// <summary>

tests/Neo.VM.Tests/UT_Utility.cs

@@ -101,5 +101,36 @@ public void TestModInverseTest()
 
             Assert.AreEqual(new BigInteger(52), new BigInteger(19).ModInverse(141));
         }
+
+        [TestMethod]
+        public void TestNotZero()
+        {
+            Assert.IsFalse(new ReadOnlySpan<byte>(System.Array.Empty<byte>()).NotZero());
+            Assert.IsFalse(new ReadOnlySpan<byte>(new byte[4]).NotZero());
+            Assert.IsFalse(new ReadOnlySpan<byte>(new byte[7]).NotZero());
+            Assert.IsFalse(new ReadOnlySpan<byte>(new byte[8]).NotZero());
+            Assert.IsFalse(new ReadOnlySpan<byte>(new byte[9]).NotZero());
+            Assert.IsFalse(new ReadOnlySpan<byte>(new byte[11]).NotZero());
+
+            Assert.IsTrue(new ReadOnlySpan<byte>(new byte[4] { 0x00, 0x00, 0x00, 0x01 }).NotZero());
+            Assert.IsTrue(new ReadOnlySpan<byte>(new byte[7] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }).NotZero());
+            Assert.IsTrue(new ReadOnlySpan<byte>(new byte[8] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }).NotZero());
+            Assert.IsTrue(new ReadOnlySpan<byte>(new byte[9] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 }).NotZero());
+            Assert.IsTrue(new ReadOnlySpan<byte>(new byte[11] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }).NotZero());
+
+            var bytes = new byte[64];
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                ReadOnlySpan<byte> span = bytes.AsSpan();
+                Assert.IsFalse(span[i..].NotZero());
+
+                for (int j = i; j < bytes.Length; j++)
+                {
+                    bytes[j] = 0x01;
+                    Assert.IsTrue(span[i..].NotZero());
+                    bytes[j] = 0x00;
+                }
+            }
+        }
     }
 }