Merge branch 'master' into fix/leveldb-deps

Author: Jim8y

src/Neo.VM/Instruction.cs

@@ -50,10 +50,10 @@ public int Size
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                int prefixSize = OperandSizePrefixTable[(int)OpCode];
+                var prefixSize = OperandSizePrefixTable[(byte)OpCode];
                 return prefixSize > 0
                     ? 1 + prefixSize + Operand.Length
-                    : 1 + OperandSizeTable[(int)OpCode];
+                    : 1 + OperandSizeTable[(byte)OpCode];
             }
         }
 
@@ -181,9 +181,9 @@ static Instruction()
         {
             foreach (FieldInfo field in typeof(OpCode).GetFields(BindingFlags.Public | BindingFlags.Static))
             {
-                OperandSizeAttribute? attribute = field.GetCustomAttribute<OperandSizeAttribute>();
+                var attribute = field.GetCustomAttribute<OperandSizeAttribute>();
                 if (attribute == null) continue;
-                int index = (int)(OpCode)field.GetValue(null)!;
+                var index = (byte)(OpCode)field.GetValue(null)!;
                 OperandSizePrefixTable[index] = attribute.SizePrefix;
                 OperandSizeTable[index] = attribute.Size;
             }
@@ -198,12 +198,12 @@ private Instruction(OpCode opcode)
         internal Instruction(ReadOnlyMemory<byte> script, int ip) : this((OpCode)script.Span[ip++])
         {
             ReadOnlySpan<byte> span = script.Span;
-            int operandSizePrefix = OperandSizePrefixTable[(int)OpCode];
+            int operandSizePrefix = OperandSizePrefixTable[(byte)OpCode];
             int operandSize = 0;
             switch (operandSizePrefix)
             {
                 case 0:
-                    operandSize = OperandSizeTable[(int)OpCode];
+                    operandSize = OperandSizeTable[(byte)OpCode];
                     break;
                 case 1:
                     if (ip >= span.Length)

src/Neo/Cryptography/Murmur128.cs

@@ -12,7 +12,6 @@
 using System;
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
-using System.Security.Cryptography;
 
 namespace Neo.Cryptography
 {
@@ -32,7 +31,8 @@ public sealed class Murmur128 : System.Security.Cryptography.HashAlgorithm
         private readonly uint seed;
         private int length;
 
-        public override int HashSize => 128;
+        public const int HashSizeInBits = 128;
+        public override int HashSize => HashSizeInBits;
 
         private ulong H1 { get; set; }
         private ulong H2 { get; set; }
@@ -44,6 +44,7 @@ public sealed class Murmur128 : System.Security.Cryptography.HashAlgorithm
         public Murmur128(uint seed)
         {
             this.seed = seed;
+            HashSizeValue = HashSizeInBits;
             Initialize();
         }
 

src/Neo/Cryptography/Murmur32.cs

@@ -11,7 +11,6 @@
 
 using System;
 using System.Buffers.Binary;
-using System.Security.Cryptography;
 
 namespace Neo.Cryptography
 {
@@ -31,7 +30,8 @@ public sealed class Murmur32 : System.Security.Cryptography.HashAlgorithm
         private uint hash;
         private int length;
 
-        public override int HashSize => 32;
+        public const int HashSizeInBits = 32;
+        public override int HashSize => HashSizeInBits;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Murmur32"/> class with the specified seed.
@@ -40,6 +40,7 @@ public sealed class Murmur32 : System.Security.Cryptography.HashAlgorithm
         public Murmur32(uint seed)
         {
             this.seed = seed;
+            HashSizeValue = HashSizeInBits;
             Initialize();
         }
 

src/Neo/Cryptography/RIPEMD160Managed.cs

@@ -12,7 +12,6 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Security;
-using System.Security.Cryptography;
 
 namespace Neo.Cryptography
 {
@@ -27,7 +26,8 @@ public class RIPEMD160Managed : System.Security.Cryptography.HashAlgorithm
         private readonly uint[] _stateMD160;
         private readonly uint[] _blockDWords;
 
-        public override int HashSize => 160;
+        public const int HashSizeInBits = 160;
+        public override int HashSize => HashSizeInBits;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="RIPEMD160Managed"/> class.
@@ -38,6 +38,7 @@ public RIPEMD160Managed()
             _blockDWords = new uint[16];
             _buffer = new byte[64];
 
+            HashSizeValue = HashSizeInBits;
             InitializeState();
         }
 

tests/Neo.UnitTests/Cryptography/UT_Murmur128.cs

@@ -42,5 +42,15 @@ public void TestHashCore()
             array = "718f952132679baa9c5c2aa0d329fd2a".HexToBytes();
             array.Murmur128(123u).ToHexString().ToString().Should().Be("9b4aa747ff0cf4e41b3d96251551c8ae");
         }
+
+        [TestMethod]
+        public void TestTryComputeHash()
+        {
+            var murmur128 = new Murmur128(123u);
+            var buffer = new byte[murmur128.HashSize / 8];
+            var ok = murmur128.TryComputeHash("hello world"u8.ToArray(), buffer, out _);
+            ok.Should().BeTrue();
+            buffer.ToHexString().Should().Be("e0a0632d4f51302c55e3b3e48d28795d");
+        }
     }
 }

tests/Neo.UnitTests/Cryptography/UT_Murmur32.cs

@@ -12,6 +12,7 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.Cryptography;
+using System.Buffers.Binary;
 
 namespace Neo.UnitTests.Cryptography
 {
@@ -31,5 +32,19 @@ public void TestHashCore()
             byte[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 };
             array.Murmur32(10u).Should().Be(378574820u);
         }
+
+        [TestMethod]
+        public void TestTryComputeHash()
+        {
+            var murmur3 = new Murmur32(10u);
+            var buffer = new byte[murmur3.HashSize / 8];
+            var data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 };
+
+            var ok = murmur3.TryComputeHash(data, buffer, out _);
+            ok.Should().BeTrue();
+
+            var hash = BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+            hash.Should().Be(378574820u);
+        }
     }
 }

tests/Neo.UnitTests/Cryptography/UT_RIPEMD160Managed.cs

@@ -0,0 +1,40 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// UT_RIPEMD160Managed.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository 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 FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Cryptography;
+using Neo.Extensions;
+
+namespace Neo.UnitTests.Cryptography
+{
+    [TestClass]
+    public class UT_RIPEMD160Managed
+    {
+        [TestMethod]
+        public void TestHashCore()
+        {
+            using var ripemd160 = new RIPEMD160Managed();
+            var hash = ripemd160.ComputeHash("hello world"u8.ToArray());
+            hash.ToHexString().Should().Be("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f");
+        }
+
+        [TestMethod]
+        public void TestTryComputeHash()
+        {
+            using var ripemd160 = new RIPEMD160Managed();
+            var buffer = new byte[ripemd160.HashSize / 8];
+            var ok = ripemd160.TryComputeHash("hello world"u8.ToArray(), buffer, out _);
+            ok.Should().BeTrue();
+            buffer.ToHexString().Should().Be("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f");
+        }
+    }
+}