Fixed hashcode for StackItem

src/Neo.VM/JumpTable/JumpTable.Compound.cs

@@ -464,6 +464,7 @@ public virtual void SetItem(ExecutionEngine engine, Instruction instruction)
                         if (b < sbyte.MinValue || b > byte.MaxValue)
                             throw new InvalidOperationException($"Overflow in {instruction.OpCode}, {b} is not a byte type.");
                         buffer.InnerBuffer.Span[index] = (byte)b;
+                        buffer.Invalidate();
                         break;
                     }
                 default:
@@ -489,6 +490,7 @@ public virtual void ReverseItems(ExecutionEngine engine, Instruction instruction
                     break;
                 case Types.Buffer buffer:
                     buffer.InnerBuffer.Span.Reverse();
+                    buffer.Invalidate();
                     break;
                 default:
                     throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}");

src/Neo.VM/JumpTable/JumpTable.Splice.cs

@@ -61,6 +61,7 @@ public virtual void Memcpy(ExecutionEngine engine, Instruction instruction)
                 throw new InvalidOperationException($"The value {count} is out of range.");
             // TODO: check if we can optimize the memcpy by using peek instead of  dup then pop
             src.Slice(si, count).CopyTo(dst.InnerBuffer.Span[di..]);
+            dst.Invalidate();
         }
 
         /// <summary>

src/Neo.VM/Script.cs

@@ -23,6 +23,7 @@ namespace Neo.VM
     [DebuggerDisplay("Length={Length}")]
     public class Script
     {
+        private int _hashCode = 0;
         private readonly ReadOnlyMemory<byte> _value;
         private readonly bool strictMode;
         private readonly Dictionary<int, Instruction> _instructions = new();
@@ -157,5 +158,15 @@ public Instruction GetInstruction(int ip)
         public static implicit operator ReadOnlyMemory<byte>(Script script) => script._value;
         public static implicit operator Script(ReadOnlyMemory<byte> script) => new(script);
         public static implicit operator Script(byte[] script) => new(script);
+
+        public override int GetHashCode()
+        {
+            if (_hashCode == 0)
+            {
+                return _hashCode = (int)Unsafe.HashBytes(_value.Span);
+            }
+
+            return _hashCode;
+        }
     }
 }

src/Neo.VM/Types/Buffer.cs

@@ -14,6 +14,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 
 namespace Neo.VM.Types
 {
@@ -112,5 +113,14 @@ public override string ToString()
         {
             return GetSpan().TryGetString(out var str) ? $"(\"{str}\")" : $"(\"Base64: {Convert.ToBase64String(GetSpan())}\")";
         }
+
+        /// <summary>
+        /// Invalidate
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Invalidate()
+        {
+            _hashCode = 0;
+        }
     }
 }

src/Neo.VM/Types/ByteString.cs

@@ -9,9 +9,7 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
-using Neo.VM.Cryptography;
 using System;
-using System.Buffers.Binary;
 using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -29,9 +27,6 @@ public class ByteString : PrimitiveType
         /// </summary>
         public static readonly ByteString Empty = ReadOnlyMemory<byte>.Empty;
 
-        private static readonly uint s_seed = unchecked((uint)new Random().Next());
-        private int _hashCode = 0;
-
         public override ReadOnlyMemory<byte> Memory { get; }
         public override StackItemType Type => StackItemType.ByteString;
 
@@ -88,16 +83,6 @@ public override bool GetBoolean()
             return Unsafe.NotZero(GetSpan());
         }
 
-        public override int GetHashCode()
-        {
-            if (_hashCode == 0)
-            {
-                using Murmur32 murmur = new(s_seed);
-                _hashCode = BinaryPrimitives.ReadInt32LittleEndian(murmur.ComputeHash(GetSpan().ToArray()));
-            }
-            return _hashCode;
-        }
-
         public override BigInteger GetInteger()
         {
             if (Size > Integer.MaxSize) throw new InvalidCastException($"MaxSize exceed: {Size}");

src/Neo.VM/Types/Pointer.cs

@@ -57,7 +57,7 @@ public override bool GetBoolean()
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(Script, Position);
+            return HashCode.Combine(Script.GetHashCode(), Position);
         }
 
         public override string ToString()

src/Neo.VM/Types/PrimitiveType.cs

@@ -47,12 +47,6 @@ internal sealed override StackItem DeepCopy(Dictionary<StackItem, StackItem> ref
 
         public abstract override bool Equals(StackItem? other);
 
-        /// <summary>
-        /// Get the hash code of the VM object, which is used for key comparison in the <see cref="Map"/>.
-        /// </summary>
-        /// <returns>The hash code of this VM object.</returns>
-        public abstract override int GetHashCode();
-
         public sealed override ReadOnlySpan<byte> GetSpan()
         {
             return Memory.Span;

src/Neo.VM/Types/StackItem.Vertex.cs

@@ -9,9 +9,9 @@
 // Redistribution and use in source and binary forms with or without
 // modifications are permitted.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace Neo.VM.Types
 {
@@ -80,6 +80,11 @@ internal class ObjectReferenceEntry
         /// </summary>
         internal int LowLink = 0;
 
+        /// <summary>
+        /// Stack Item hashcode
+        /// </summary>
+        protected int _hashCode = 0;
+
         /// <summary>
         /// Indicates whether the item is currently on the stack for Tarjan's algorithm.
         ///
@@ -120,7 +125,14 @@ internal class ObjectReferenceEntry
         /// Use this method when you need a hash code for a StackItem.
         /// </summary>
         /// <returns>The hash code for the StackItem.</returns>
-        public override int GetHashCode() =>
-            HashCode.Combine(GetSpan().ToArray());
+        public override int GetHashCode()
+        {
+            if (_hashCode == 0)
+            {
+                return _hashCode = (int)Unsafe.HashBytes(GetSpan());
+            }
+
+            return _hashCode;
+        }
     }
 }

src/Neo.VM/Unsafe.cs

@@ -16,6 +16,8 @@ namespace Neo.VM
 {
     unsafe internal static class Unsafe
     {
+        const long HashMagicNumber = 40343;
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool NotZero(ReadOnlySpan<byte> x)
         {
@@ -38,5 +40,40 @@ public static bool NotZero(ReadOnlySpan<byte> x)
             }
             return false;
         }
+
+        /// <summary>
+        /// Get 64-bit hash code for a byte array
+        /// </summary>
+        /// <param name="span">Span</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static long HashBytes(ReadOnlySpan<byte> span)
+        {
+            var len = span.Length;
+            var hashState = (ulong)len;
+
+            fixed (byte* k = span)
+            {
+                var pwString = (char*)k;
+                var cbBuf = len / 2;
+
+                for (var i = 0; i < cbBuf; i++, pwString++)
+                    hashState = HashMagicNumber * hashState + *pwString;
+
+                if ((len & 1) > 0)
+                {
+                    var pC = (byte*)pwString;
+                    hashState = HashMagicNumber * hashState + *pC;
+                }
+            }
+
+            return (long)Rotr64(HashMagicNumber * hashState, 4);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static ulong Rotr64(ulong x, int n)
+        {
+            return ((x) >> n) | ((x) << (64 - n));
+        }
     }
 }

tests/Neo.VM.Tests/UT_StackItem.cs

@@ -31,8 +31,17 @@ public void TestHashCode()
 
             itemA = new VM.Types.Buffer(1);
             itemB = new VM.Types.Buffer(1);
+            itemC = new VM.Types.Buffer(2);
 
-            Assert.IsTrue(itemA.GetHashCode() != itemB.GetHashCode());
+            Assert.IsTrue(itemA.GetHashCode() == itemB.GetHashCode());
+            Assert.IsTrue(itemA.GetHashCode() != itemC.GetHashCode());
+
+            itemA = new byte[] { 1, 2, 3 };
+            itemB = new byte[] { 1, 2, 3 };
+            itemC = new byte[] { 5, 6 };
+
+            Assert.IsTrue(itemA.GetHashCode() == itemB.GetHashCode());
+            Assert.IsTrue(itemA.GetHashCode() != itemC.GetHashCode());
 
             itemA = true;
             itemB = true;