v0.12: AddressValidator

justdmitry · justdmitry · commit 78488e1cd59b · 2023-04-07T13:10:19.000+03:00
diff --git a/TonLibDotNet.Tests/Utils/AddressValidatorMakeTests.cs b/TonLibDotNet.Tests/Utils/AddressValidatorMakeTests.cs
@@ -0,0 +1,47 @@
+﻿namespace TonLibDotNet.Utils
+{
+    public class AddressValidatorMakeTests
+    {
+        [Theory]
+        // Wallet Bot
+        [InlineData(0, "dddcd3cdad60af4c0d69389f567ad51d0c263fa4968d655ab424c69aadaf9322", "EQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIp90")]
+        // BSC Bridge
+        [InlineData(-1, "4d5c0210b35daddaa219fac459dba0fdefb1fae4e97a0d0797739fe050d694ca", "Ef9NXAIQs12t2qIZ-sRZ26D977H65Ol6DQeXc5_gUNaUys5r")]
+        public void ItWorks(int workchainId, string accountIdHex, string expected)
+        {
+            var accountId = Convert.FromHexString(accountIdHex);
+            var account = AddressValidator.MakeAddress((byte)workchainId, accountId);
+            Assert.Equal(expected, account);
+        }
+
+        [Theory]
+        // Wallet Bot
+        [InlineData(0, "dddcd3cdad60af4c0d69389f567ad51d0c263fa4968d655ab424c69aadaf9322", "UQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIsKx")]
+        public void NonBounceableWorks(int workchainId, string accountIdHex, string expected)
+        {
+            var accountId = Convert.FromHexString(accountIdHex);
+            var account = AddressValidator.MakeAddress((byte)workchainId, accountId, bounceable: false);
+            Assert.Equal(expected, account);
+        }
+
+        [Theory]
+        // "test giver" smart contract
+        [InlineData(-1, "fcb91a3a3816d0f7b8c2c76108b8a9bc5a6b7a55bd79f8ab101c52db29232260", "kf_8uRo6OBbQ97jCx2EIuKm8Wmt6Vb15-KsQHFLbKSMiYIny")]
+        public void TestnetOnlyWorks(int workchainId, string accountIdHex, string expected)
+        {
+            var accountId = Convert.FromHexString(accountIdHex);
+            var account = AddressValidator.MakeAddress((byte)workchainId, accountId, testnetOnly: true);
+            Assert.Equal(expected, account);
+        }
+
+        [Theory]
+        // "test giver" smart contract
+        [InlineData(-1, "fcb91a3a3816d0f7b8c2c76108b8a9bc5a6b7a55bd79f8ab101c52db29232260", "kf/8uRo6OBbQ97jCx2EIuKm8Wmt6Vb15+KsQHFLbKSMiYIny")]
+        public void UrlSafeWorks(int workchainId, string accountIdHex, string expected)
+        {
+            var accountId = Convert.FromHexString(accountIdHex);
+            var account = AddressValidator.MakeAddress((byte)workchainId, accountId, testnetOnly: true, urlSafe: false);
+            Assert.Equal(expected, account);
+        }
+    }
+}
diff --git a/TonLibDotNet.Tests/Utils/AddressValidatorParseTests.cs b/TonLibDotNet.Tests/Utils/AddressValidatorParseTests.cs
@@ -0,0 +1,77 @@
+﻿namespace TonLibDotNet.Utils
+{
+    public class AddressValidatorParseTests
+    {
+        [Fact]
+        public void ParseDefault()
+        {
+            // Wallet Bot
+            Assert.True(AddressValidator.TryParseAddress("EQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIp90", out var workchainId, out var accountId, out var bounceable, out var testnetOnly, out var urlSafe));
+
+            Assert.Equal(0, workchainId);
+            Assert.Equal("dddcd3cdad60af4c0d69389f567ad51d0c263fa4968d655ab424c69aadaf9322", Convert.ToHexString(accountId), true);
+            Assert.True(bounceable);
+            Assert.False(testnetOnly);
+            Assert.True(urlSafe);
+        }
+
+        [Fact]
+        public void ParseMasterchain()
+        {
+            // BSC Bridge
+            Assert.True(AddressValidator.TryParseAddress("Ef9NXAIQs12t2qIZ-sRZ26D977H65Ol6DQeXc5_gUNaUys5r", out var workchainId, out var accountId, out var bounceable, out var testnetOnly, out var urlSafe));
+
+            Assert.Equal(AddressValidator.MasterchainId, workchainId);
+            Assert.Equal("4d5c0210b35daddaa219fac459dba0fdefb1fae4e97a0d0797739fe050d694ca", Convert.ToHexString(accountId), true);
+        }
+
+        [Fact]
+        public void ParseNonBounceable()
+        {
+            // Wallet Bot
+            Assert.True(AddressValidator.TryParseAddress("UQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIsKx", out var workchainId, out var accountId, out var bounceable, out var testnetOnly, out var urlSafe));
+
+            Assert.Equal(0, workchainId);
+            Assert.Equal("dddcd3cdad60af4c0d69389f567ad51d0c263fa4968d655ab424c69aadaf9322", Convert.ToHexString(accountId), true);
+            Assert.False(bounceable);
+        }
+
+        [Fact]
+        public void ParseUrlUnsafe()
+        {
+            // Wallet Bot
+            Assert.True(AddressValidator.TryParseAddress("EQDd3NPNrWCvTA1pOJ9WetUdDCY/pJaNZVq0JMaara+TIp90", out var workchainId, out var accountId, out var bounceable, out var testnetOnly, out var urlSafe));
+
+            Assert.Equal(0, workchainId);
+            Assert.Equal("dddcd3cdad60af4c0d69389f567ad51d0c263fa4968d655ab424c69aadaf9322", Convert.ToHexString(accountId), true);
+            Assert.False(urlSafe);
+        }
+
+        [Fact]
+        public void FailsOnWrongStringLength()
+        {
+            Assert.False(AddressValidator.TryParseAddress("EQDd3NPNrWCvTA1pOJ9WetUdDC", out _, out _, out _, out _, out _));
+        }
+
+        [Fact]
+        public void FailsOnNonBase64()
+        {
+            // Wallet Bot, with '~' in first position
+            Assert.False(AddressValidator.TryParseAddress("~QDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIp90", out _, out _, out _, out _, out _));
+        }
+
+        [Fact]
+        public void FailsOnWrongChecksum()
+        {
+            // Wallet Bot, but last char changed from 0 to 1
+            Assert.False(AddressValidator.TryParseAddress("EQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara-TIp91", out _, out _, out _, out _, out _));
+        }
+
+        [Fact]
+        public void FailsOnSafeUnsafeMix()
+        {
+            // Wallet Bot, with '_' changed to '+', but '_' not changed to '/'
+            Assert.False(AddressValidator.TryParseAddress("EQDd3NPNrWCvTA1pOJ9WetUdDCY_pJaNZVq0JMaara+TIp90", out _, out _, out _, out _, out _));
+        }
+    }
+}
diff --git a/TonLibDotNet/TonLibDotNet.csproj b/TonLibDotNet/TonLibDotNet.csproj
@@ -16,8 +16,8 @@
     <RepositoryType>git</RepositoryType>
     <PackageTags>ton, toncoin, the-open-network, tonlib, libtonlibjson</PackageTags>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <Version>0.11.0</Version>
-    <PackageReleaseNotes>TVM.* and SMC.* classes added (now you can call get-methods on smartcontracts, check Demo project for details).</PackageReleaseNotes>
+    <Version>0.12.0</Version>
+    <PackageReleaseNotes>New: AddressValidator to check addresses, typed by users, without calling tonlib/liteclient: detect bounceable/non-bounceable and testnet-only, check workchain-id, verify checksum. Build address string with required param values.</PackageReleaseNotes>
     <Description>TonLib (libtonlibjson) wrapper for accessing Telegram Open Network lite servers (nodes) via ADNL protocol.</Description>
   </PropertyGroup>
 
diff --git a/TonLibDotNet/Utils/AddressValidator.cs b/TonLibDotNet/Utils/AddressValidator.cs
@@ -0,0 +1,143 @@
+﻿using System.Diagnostics.CodeAnalysis;
+
+namespace TonLibDotNet.Utils
+{
+    /// <seealso href="https://docs.ton.org/learn/overviews/addresses#user-friendly-address">User-Friendly Address Structure</seealso>
+    public static class AddressValidator
+    {
+        public const byte FlagBounceable = 0x11;
+        public const byte FlagNonBounceable = 0x51;
+        public const byte FlagTestnetOnly = 0x80;
+
+        public const byte BasechainId = 0x00;
+        public const byte MasterchainId = 0xFF;
+
+        public static string MakeAddress(byte workchainId, byte[] accountId, bool bounceable = true, bool testnetOnly = false, bool urlSafe = true)
+        {
+            ArgumentNullException.ThrowIfNull(accountId);
+
+            if (accountId.Length != 32)
+            {
+                throw new ArgumentException("Must be 32 bytes", nameof(accountId));
+            }
+
+            var bytes = new byte[36];
+
+            bytes[0] = bounceable ? FlagBounceable : FlagNonBounceable;
+
+            if (testnetOnly)
+            {
+                bytes[0] |= FlagTestnetOnly;
+            }
+
+            bytes[1] = workchainId;
+
+            accountId.CopyTo(bytes, 2);
+
+            var span = bytes.AsSpan();
+            var crc = Crc16.Ccitt.ComputeChecksum(span[..^2]);
+            System.Buffers.Binary.BinaryPrimitives.WriteUInt16BigEndian(span[^2..], crc);
+
+            var address = Convert.ToBase64String(bytes);
+
+            if (!urlSafe)
+            {
+                return address;
+            }
+
+            // use '_' and '-' instead of '/' and '+'
+            var chars = address.ToCharArray();
+            for (var i = 0; i < chars.Length; i++)
+            {
+                if (chars[i] == '/')
+                {
+                    chars[i] = '_';
+                }
+                else if (chars[i] == '+')
+                {
+                    chars[i] = '-';
+                }
+            }
+
+            return new string(chars);
+        }
+
+        public static bool TryParseAddress(
+            string address,
+            out byte workchainId,
+            [NotNullWhen(true)] out byte[]? accountId,
+            out bool bounceable,
+            out bool testnetOnly,
+            out bool urlSafe)
+        {
+            if (string.IsNullOrEmpty(address))
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            workchainId = default;
+            accountId = default;
+            bounceable = default;
+            testnetOnly = default;
+            urlSafe = default;
+
+            if (address.Length != 48)
+            {
+                return false;
+            }
+
+            var chars = address.ToCharArray();
+            var safeFound = false;
+            var unsafeFound = false;
+            for (var i = 0; i < chars.Length; i++)
+            {
+                switch (chars[i])
+                {
+                    case '/':
+                    case '+':
+                        unsafeFound = true;
+                        break;
+
+                    case '_':
+                        safeFound = true;
+                        chars[i] = '/';
+                        break;
+
+                    case '-':
+                        safeFound = true;
+                        chars[i] = '+';
+                        break;
+                }
+            }
+
+            if (safeFound && unsafeFound)
+            {
+                return false;
+            }
+
+            urlSafe = !unsafeFound;
+
+            var bytes = new byte[36];
+
+            if (!Convert.TryFromBase64Chars(chars, bytes, out _))
+            {
+                return false;
+            }
+
+            testnetOnly = (bytes[0] & FlagTestnetOnly) == FlagTestnetOnly;
+
+            bounceable = (bytes[0] & FlagNonBounceable) == FlagBounceable;
+
+            workchainId = bytes[1];
+            accountId = bytes[2..^2].ToArray();
+
+            var checksum = Crc16.Ccitt.ComputeChecksum(bytes);
+            if (checksum != 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/TonLibDotNet/Utils/Crc16.cs b/TonLibDotNet/Utils/Crc16.cs
@@ -0,0 +1,51 @@
+﻿using System.Buffers.Binary;
+
+namespace TonLibDotNet.Utils
+{
+    /// <summary>
+    /// Based on http://sanity-free.org/133/crc_16_ccitt_in_csharp.html
+    /// </summary>
+    public class Crc16
+    {
+        private readonly ushort[] table = new ushort[256];
+
+        public Crc16(ushort initialValue, ushort poly)
+        {
+            this.InitialValue = initialValue;
+
+            ushort temp, a;
+            for (int i = 0; i < table.Length; ++i)
+            {
+                temp = 0;
+                a = (ushort)(i << 8);
+                for (int j = 0; j < 8; ++j)
+                {
+                    if (((temp ^ a) & 0x8000) != 0)
+                    {
+                        temp = (ushort)((temp << 1) ^ poly);
+                    }
+                    else
+                    {
+                        temp <<= 1;
+                    }
+                    a <<= 1;
+                }
+                table[i] = temp;
+            }
+        }
+
+        public static Crc16 Ccitt { get; } = new Crc16(0x0000, 0x1021);
+
+        public ushort InitialValue { get; private set; }
+
+        public ushort ComputeChecksum(ReadOnlySpan<byte> bytes)
+        {
+            ushort crc = InitialValue;
+            for (int i = 0; i < bytes.Length; ++i)
+            {
+                crc = (ushort)((crc << 8) ^ table[(crc >> 8) ^ (0xff & bytes[i])]);
+            }
+            return crc;
+        }
+    }
+}
