Preview5 to RC1 Comparison

.editorconfig

@@ -15,3 +15,5 @@ insert_final_newline = true
 trim_trailing_whitespace = true
 charset = utf-8
 end_of_line = lf
+
+dotnet_diagnostic.CS1591.severity = silent

src/neo/BigDecimal.cs

@@ -3,50 +3,69 @@
 
 namespace Neo
 {
+    /// <summary>
+    /// Represents a fixed-point number of arbitrary precision.
+    /// </summary>
     public struct BigDecimal
     {
         private readonly BigInteger value;
         private readonly byte decimals;
 
+        /// <summary>
+        /// The <see cref="BigInteger"/> value of the number.
+        /// </summary>
         public BigInteger Value => value;
+
+        /// <summary>
+        /// The number of decimal places for this number.
+        /// </summary>
         public byte Decimals => decimals;
+
+        /// <summary>
+        /// The sign of the number.
+        /// </summary>
         public int Sign => value.Sign;
 
         /// <summary>
-        /// Create BigDecimal from BigInteger
+        /// Initializes a new instance of the <see cref="BigDecimal"/> struct.
         /// </summary>
-        /// <param name="value">Value</param>
-        /// <param name="decimals">Decimals</param>
+        /// <param name="value">The <see cref="BigInteger"/> value of the number.</param>
+        /// <param name="decimals">The number of decimal places for this number.</param>
         public BigDecimal(BigInteger value, byte decimals)
         {
             this.value = value;
             this.decimals = decimals;
         }
 
         /// <summary>
-        /// Create BigDecimal from decimal
+        /// Initializes a new instance of the <see cref="BigDecimal"/> struct with the value of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="value">Value</param>
+        /// <param name="value">The value of the number.</param>
         public unsafe BigDecimal(decimal value)
         {
-            ReadOnlySpan<byte> buffer = new ReadOnlySpan<byte>(&value, sizeof(decimal));
+            ReadOnlySpan<byte> buffer = new(&value, sizeof(decimal));
             this.decimals = buffer[14];
             this.value = new BigInteger(decimal.Multiply((decimal)Math.Pow(10, decimals), value));
         }
 
         /// <summary>
-        /// Create BigDecimal from decimal
+        /// Initializes a new instance of the <see cref="BigDecimal"/> struct with the value of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="value">Value</param>
-        /// <param name="decimals">Decimals</param>
+        /// <param name="value">The value of the number.</param>
+        /// <param name="decimals">The number of decimal places for this number.</param>
         public unsafe BigDecimal(decimal value, byte decimals)
         {
-            ReadOnlySpan<byte> buffer = new ReadOnlySpan<byte>(&value, sizeof(decimal));
+            ReadOnlySpan<byte> buffer = new(&value, sizeof(decimal));
             if (buffer[14] > decimals) throw new ArgumentException(null, nameof(value));
             this.value = new BigInteger(decimal.Multiply((decimal)Math.Pow(10, decimals), value));
             this.decimals = decimals;
         }
 
+        /// <summary>
+        /// Changes the decimals of the <see cref="BigDecimal"/>.
+        /// </summary>
+        /// <param name="decimals">The new decimals field.</param>
+        /// <returns>The <see cref="BigDecimal"/> that has the new number of decimal places.</returns>
         public BigDecimal ChangeDecimals(byte decimals)
         {
             if (this.decimals == decimals) return this;
@@ -60,18 +79,29 @@ public BigDecimal ChangeDecimals(byte decimals)
                 BigInteger divisor = BigInteger.Pow(10, this.decimals - decimals);
                 value = BigInteger.DivRem(this.value, divisor, out BigInteger remainder);
                 if (remainder > BigInteger.Zero)
-                    throw new ArgumentOutOfRangeException();
+                    throw new ArgumentOutOfRangeException(nameof(decimals));
             }
             return new BigDecimal(value, decimals);
         }
 
+        /// <summary>
+        /// Parses a <see cref="BigDecimal"/> from the specified <see cref="string"/>.
+        /// </summary>
+        /// <param name="s">A number represented by a <see cref="string"/>.</param>
+        /// <param name="decimals">The number of decimal places for this number.</param>
+        /// <returns>The parsed <see cref="BigDecimal"/>.</returns>
+        /// <exception cref="FormatException"><paramref name="s"/> is not in the correct format.</exception>
         public static BigDecimal Parse(string s, byte decimals)
         {
             if (!TryParse(s, decimals, out BigDecimal result))
                 throw new FormatException();
             return result;
         }
 
+        /// <summary>
+        /// Gets a <see cref="string"/> representing the number.
+        /// </summary>
+        /// <returns>The <see cref="string"/> representing the number.</returns>
         public override string ToString()
         {
             BigInteger divisor = BigInteger.Pow(10, decimals);
@@ -80,15 +110,22 @@ public override string ToString()
             return $"{result}.{remainder.ToString("d" + decimals)}".TrimEnd('0');
         }
 
+        /// <summary>
+        /// Parses a <see cref="BigDecimal"/> from the specified <see cref="string"/>.
+        /// </summary>
+        /// <param name="s">A number represented by a <see cref="string"/>.</param>
+        /// <param name="decimals">The number of decimal places for this number.</param>
+        /// <param name="result">The parsed <see cref="BigDecimal"/>.</param>
+        /// <returns><see langword="true"/> if a number is successfully parsed; otherwise, <see langword="false"/>.</returns>
         public static bool TryParse(string s, byte decimals, out BigDecimal result)
         {
             int e = 0;
             int index = s.IndexOfAny(new[] { 'e', 'E' });
             if (index >= 0)
             {
-                if (!sbyte.TryParse(s.Substring(index + 1), out sbyte e_temp))
+                if (!sbyte.TryParse(s[(index + 1)..], out sbyte e_temp))
                 {
-                    result = default(BigDecimal);
+                    result = default;
                     return false;
                 }
                 e = e_temp;
@@ -104,14 +141,14 @@ public static bool TryParse(string s, byte decimals, out BigDecimal result)
             int ds = e + decimals;
             if (ds < 0)
             {
-                result = default(BigDecimal);
+                result = default;
                 return false;
             }
             if (ds > 0)
                 s += new string('0', ds);
             if (!BigInteger.TryParse(s, out BigInteger value))
             {
-                result = default(BigDecimal);
+                result = default;
                 return false;
             }
             result = new BigDecimal(value, decimals);

src/neo/Cryptography/Base58.cs

@@ -6,10 +6,21 @@
 
 namespace Neo.Cryptography
 {
+    /// <summary>
+    /// A helper class for base-58 encoder.
+    /// </summary>
     public static class Base58
     {
+        /// <summary>
+        /// Represents the alphabet of the base-58 encoder.
+        /// </summary>
         public const string Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
+        /// <summary>
+        /// Converts the specified <see cref="string"/>, which encodes binary data as base-58 digits, to an equivalent byte array. The encoded <see cref="string"/> contains the checksum of the binary data.
+        /// </summary>
+        /// <param name="input">The <see cref="string"/> to convert.</param>
+        /// <returns>A byte array that is equivalent to <paramref name="input"/>.</returns>
         public static byte[] Base58CheckDecode(this string input)
         {
             if (input is null) throw new ArgumentNullException(nameof(input));
@@ -23,6 +34,11 @@ public static byte[] Base58CheckDecode(this string input)
             return ret;
         }
 
+        /// <summary>
+        /// Converts a byte array to its equivalent <see cref="string"/> representation that is encoded with base-58 digits. The encoded <see cref="string"/> contains the checksum of the binary data.
+        /// </summary>
+        /// <param name="data">The byte array to convert.</param>
+        /// <returns>The <see cref="string"/> representation, in base-58, of the contents of <paramref name="data"/>.</returns>
         public static string Base58CheckEncode(this ReadOnlySpan<byte> data)
         {
             byte[] checksum = data.Sha256().Sha256();
@@ -34,6 +50,11 @@ public static string Base58CheckEncode(this ReadOnlySpan<byte> data)
             return ret;
         }
 
+        /// <summary>
+        /// Converts the specified <see cref="string"/>, which encodes binary data as base-58 digits, to an equivalent byte array.
+        /// </summary>
+        /// <param name="input">The <see cref="string"/> to convert.</param>
+        /// <returns>A byte array that is equivalent to <paramref name="input"/>.</returns>
         public static byte[] Decode(string input)
         {
             // Decode Base58 string to BigInteger 
@@ -55,10 +76,15 @@ public static byte[] Decode(string input)
             return Concat(leadingZeros, bytesWithoutLeadingZeros);
         }
 
+        /// <summary>
+        /// Converts a byte array to its equivalent <see cref="string"/> representation that is encoded with base-58 digits.
+        /// </summary>
+        /// <param name="input">The byte array to convert.</param>
+        /// <returns>The <see cref="string"/> representation, in base-58, of the contents of <paramref name="input"/>.</returns>
         public static string Encode(ReadOnlySpan<byte> input)
         {
             // Decode byte[] to BigInteger
-            BigInteger value = new BigInteger(input, isUnsigned: true, isBigEndian: true);
+            BigInteger value = new(input, isUnsigned: true, isBigEndian: true);
 
             // Encode BigInteger to Base58 string
             var sb = new StringBuilder();

src/neo/Cryptography/BloomFilter.cs

@@ -4,17 +4,36 @@
 
 namespace Neo.Cryptography
 {
+    /// <summary>
+    /// Represents a bloom filter.
+    /// </summary>
     public class BloomFilter
     {
         private readonly uint[] seeds;
         private readonly BitArray bits;
 
+        /// <summary>
+        /// The number of hash functions used by the bloom filter.
+        /// </summary>
         public int K => seeds.Length;
 
+        /// <summary>
+        /// The size of the bit array used by the bloom filter.
+        /// </summary>
         public int M => bits.Length;
 
+        /// <summary>
+        /// Used to generate the seeds of the murmur hash functions.
+        /// </summary>
         public uint Tweak { get; private set; }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BloomFilter"/> class.
+        /// </summary>
+        /// <param name="m">The size of the bit array used by the bloom filter.</param>
+        /// <param name="k">The number of hash functions used by the bloom filter.</param>
+        /// <param name="nTweak">Used to generate the seeds of the murmur hash functions.</param>
+        /// <param name="elements">The initial elements contained in this <see cref="BloomFilter"/> object.</param>
         public BloomFilter(int m, int k, uint nTweak, byte[] elements = null)
         {
             if (k < 0 || m < 0) throw new ArgumentOutOfRangeException();
@@ -24,12 +43,21 @@ public BloomFilter(int m, int k, uint nTweak, byte[] elements = null)
             this.Tweak = nTweak;
         }
 
+        /// <summary>
+        /// Adds an element to the <see cref="BloomFilter"/>.
+        /// </summary>
+        /// <param name="element">The object to add to the <see cref="BloomFilter"/>.</param>
         public void Add(byte[] element)
         {
             foreach (uint i in seeds.AsParallel().Select(s => element.Murmur32(s)))
                 bits.Set((int)(i % (uint)bits.Length), true);
         }
 
+        /// <summary>
+        /// Determines whether the <see cref="BloomFilter"/> contains a specific element.
+        /// </summary>
+        /// <param name="element">The object to locate in the <see cref="BloomFilter"/>.</param>
+        /// <returns><see langword="true"/> if <paramref name="element"/> is found in the <see cref="BloomFilter"/>; otherwise, <see langword="false"/>.</returns>
         public bool Check(byte[] element)
         {
             foreach (uint i in seeds.AsParallel().Select(s => element.Murmur32(s)))
@@ -38,6 +66,10 @@ public bool Check(byte[] element)
             return true;
         }
 
+        /// <summary>
+        /// Gets the bit array in this <see cref="BloomFilter"/>.
+        /// </summary>
+        /// <param name="newBits">The byte array to store the bits.</param>
         public void GetBits(byte[] newBits)
         {
             bits.CopyTo(newBits, 0);