TonUtils.Adnl, Base32

Author: justdmitry

TonLibDotNet.Tests/Utils/AdnlUtilsTests.cs

@@ -0,0 +1,21 @@
+namespace TonLibDotNet.Utils
+{
+    public class AdnlUtilsTests
+    {
+        [Theory]
+        [InlineData("UWYYz2y+kAT2iD50LJouPKU+0C4+NvTO9iqY7h5EkXQ=", "viwmggpns7jabhwra7hile2fy6kkpwqfy7dn5go6yvjr3q6isixjwkf")]
+        public void Encode(string source, string result)
+        {
+            var bytes = Convert.FromBase64String(source);
+            Assert.Equal(result, AdnlUtils.Instance.Encode(bytes));
+        }
+
+        [Theory]
+        [InlineData("viwmggpns7jabhwra7hile2fy6kkpwqfy7dn5go6yvjr3q6isixjwkf", "UWYYz2y+kAT2iD50LJouPKU+0C4+NvTO9iqY7h5EkXQ=")]
+        public void Decode(string source, string result)
+        {
+            var bytes = AdnlUtils.Instance.Decode(source);
+            Assert.Equal(result, Convert.ToBase64String(bytes));
+        }
+    }
+}

TonLibDotNet/TonUtils.cs

@@ -19,5 +19,10 @@ public static class TonUtils
         /// Useful function to work with text strings.
         /// </summary>
         public static TextUtils Text { get; } = TextUtils.Instance;
+
+        /// <summary>
+        /// Useful function to work with ADNL addresses.
+        /// </summary>
+        public static AdnlUtils Adnl { get; } = AdnlUtils.Instance;
     }
 }

TonLibDotNet/Utils/AdnlUtils.cs

@@ -0,0 +1,54 @@
+namespace TonLibDotNet.Utils
+{
+    public class AdnlUtils
+    {
+        public static readonly AdnlUtils Instance = new ();
+
+        /// <summary>
+        /// Encodes 256bit ADNL address into 55-characters string.
+        /// </summary>
+        /// <param name="adnl">ADNL address bytes.</param>
+        /// <returns>String ADNL representation (55 characters).</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Source byte array length is not equal to 32.</exception>
+        /// <seealso href="https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/common/util.cpp#L195">Reference implementation</seealso>
+        public string Encode(ReadOnlySpan<byte> adnl)
+        {
+            if (adnl.Length != 32)
+            {
+                throw new ArgumentOutOfRangeException(nameof(adnl), "Must be 32 bytes");
+            }
+
+            Span<byte> buf = stackalloc byte[35];
+            buf[0] = 0x2d;
+            adnl.CopyTo(buf[1..]);
+            var crc = Crc16.Ccitt.ComputeChecksum(buf[..33]);
+            buf[33] = (byte)((crc >> 8) & 0xFF);
+            buf[34] = (byte)(crc & 0xFF);
+
+            return Base32.Encode(buf).ToLowerInvariant()[1..];
+        }
+
+        /// <summary>
+        /// Decodes ADNL address string into 32 bytes (256 bits).
+        /// </summary>
+        /// <param name="adnl">ADNL address as string (55 characters).</param>
+        /// <returns>ADNL address as 32 bytes.</returns>
+        /// <exception cref="ArgumentNullException">Input string is null or empty.</exception>
+        /// <exception cref="ArgumentException">Input string length is not 55.</exception>
+        public Span<byte> Decode(string adnl)
+        {
+            if (string.IsNullOrEmpty(adnl))
+            {
+                throw new ArgumentNullException(nameof(adnl));
+            }
+
+            if (adnl.Length != 55)
+            {
+                throw new ArgumentException("Must be 55 characters", nameof(adnl));
+            }
+
+            var bytes = Base32.Decode("F" + adnl);
+            return bytes.AsSpan(1, 32);
+        }
+    }
+}

TonLibDotNet/Utils/Base32.cs

@@ -0,0 +1,130 @@
+namespace TonLibDotNet.Utils
+{
+    /// <summary>
+    /// Based on <see href="https://stackoverflow.com/questions/641361/base32-decoding"/>.
+    /// </summary>
+    public static class Base32
+    {
+        public static byte[] Decode(string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                throw new ArgumentNullException(nameof(input));
+            }
+
+            input = input.TrimEnd('='); //remove padding characters
+            int byteCount = input.Length * 5 / 8; //this must be TRUNCATED
+            byte[] returnArray = new byte[byteCount];
+
+            byte curByte = 0, bitsRemaining = 8;
+            int mask = 0, arrayIndex = 0;
+
+            foreach (char c in input)
+            {
+                int cValue = CharToValue(c);
+
+                if (bitsRemaining > 5)
+                {
+                    mask = cValue << (bitsRemaining - 5);
+                    curByte = (byte)(curByte | mask);
+                    bitsRemaining -= 5;
+                }
+                else
+                {
+                    mask = cValue >> (5 - bitsRemaining);
+                    curByte = (byte)(curByte | mask);
+                    returnArray[arrayIndex++] = curByte;
+                    curByte = (byte)(cValue << (3 + bitsRemaining));
+                    bitsRemaining += 3;
+                }
+            }
+
+            //if we didn't end with a full byte
+            if (arrayIndex != byteCount)
+            {
+                returnArray[arrayIndex] = curByte;
+            }
+
+            return returnArray;
+        }
+
+        public static string Encode(ReadOnlySpan<byte> input)
+        {
+            if (input.Length == 0)
+            {
+                throw new ArgumentNullException(nameof(input));
+            }
+
+            int charCount = (int)Math.Ceiling(input.Length / 5d) * 8;
+            Span<char> returnArray = stackalloc char[charCount];
+
+            byte nextChar = 0, bitsRemaining = 5;
+            int arrayIndex = 0;
+
+            foreach (byte b in input)
+            {
+                nextChar = (byte)(nextChar | (b >> (8 - bitsRemaining)));
+                returnArray[arrayIndex++] = ValueToChar(nextChar);
+
+                if (bitsRemaining < 4)
+                {
+                    nextChar = (byte)((b >> (3 - bitsRemaining)) & 31);
+                    returnArray[arrayIndex++] = ValueToChar(nextChar);
+                    bitsRemaining += 5;
+                }
+
+                bitsRemaining -= 3;
+                nextChar = (byte)((b << bitsRemaining) & 31);
+            }
+
+            //if we didn't end with a full char
+            if (arrayIndex != charCount)
+            {
+                returnArray[arrayIndex++] = ValueToChar(nextChar);
+                while (arrayIndex != charCount) returnArray[arrayIndex++] = '='; //padding
+            }
+
+            return new string(returnArray);
+        }
+
+        private static int CharToValue(char c)
+        {
+            int value = c;
+
+            //65-90 == uppercase letters
+            if (value < 91 && value > 64)
+            {
+                return value - 65;
+            }
+
+            //50-55 == numbers 2-7
+            if (value < 56 && value > 49)
+            {
+                return value - 24;
+            }
+
+            //97-122 == lowercase letters
+            if (value < 123 && value > 96)
+            {
+                return value - 97;
+            }
+
+            throw new ArgumentException("Character is not a Base32 character.", nameof(c));
+        }
+
+        private static char ValueToChar(byte b)
+        {
+            if (b < 26)
+            {
+                return (char)(b + 65);
+            }
+
+            if (b < 32)
+            {
+                return (char)(b + 24);
+            }
+
+            throw new ArgumentException("Byte is not a valid Base32 value.", nameof(b));
+        }
+    }
+}