TonRecipes with RootDnsRecipes

Author: justdmitry

TonLibDotNet.Demo/Samples/DomainAuctionInfo.cs

@@ -1,5 +1,4 @@
 using Microsoft.Extensions.Logging;
-using TonLibDotNet.Types;
 using TonLibDotNet.Types.Msg;
 using TonLibDotNet.Types.Smc;
 
@@ -26,79 +25,58 @@ public async Task Run(bool useMainnet)
 
             await tonClient.InitIfNeeded();
 
-            // Step 1: find some actual domain auction.
-            // We need to check last IN transactions on ".ton DNS" address
-            var dnsAddress = new AccountAddress("EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz");
-            var dnsState = await tonClient.GetAccountState(dnsAddress);
-            var dnsTransactions = await tonClient.RawGetTransactions(dnsAddress, dnsState.LastTransactionId);
-            var dnsTx = dnsTransactions.TransactionsList.FirstOrDefault(x => x.InMsg != null && x.InMsg.MsgData is DataText dt && !string.IsNullOrEmpty(dt.Text));
-            if (dnsTx == null)
+            // First, we need to find some actual domain auction.
+            var (domainName, domainAddress) = await FindDomainOnAuction();
+            if (string.IsNullOrEmpty(domainName))
             {
-                logger.LogError("Failed to find last Domain transaction");
+                logger.LogError("Failed to find last Domain-on-Auction transaction");
                 return;
             }
 
-            TonUtils.Text.TryDecodeBase64((dnsTx.InMsg.MsgData as DataText).Text, out var domain);
-
-            var domainAddress = dnsTx.OutMsgs[0].Destination;
-            var bid = TonUtils.Coins.FromNano(dnsTx.OutMsgs[0].Value);
-
-            logger.LogInformation("Last auction found: name {Name}.ton (address {Address}), last bid = {Value} TON, bidder is {Address}", domain, domainAddress.Value, bid, dnsTx.InMsg.Source.Value);
-
-            // Step 2: Get some data from NFT
-            var smc = await tonClient.SmcLoad(domainAddress);
-
-            // Method 1: Call get_auction_info, it returns:
+            // Method 1: Call get_auction_info manually, it returns:
             // ;; MsgAddressInt max_bid_address
             // ;; Coins max_bid_amount
             // ;; int auction_end_time
+            var smc = await tonClient.SmcLoad(domainAddress);
             var smcgai = await tonClient.SmcRunGetMethod(smc.Id, new MethodIdName("get_auction_info"));
             var adr = smcgai.Stack[0].ToTvmCell().ToBoc().RootCells[0].BeginRead().LoadAddressIntStd();
             var coins = long.Parse(smcgai.Stack[1].ToTvmNumberDecimal());
             var endTime = long.Parse(smcgai.Stack[2].ToTvmNumberDecimal());
             logger.LogInformation("Auction info (method 1): last bid = {Value} TON, bidder is {Address}, auction ends at {Time}", TonUtils.Coins.FromNano(coins), adr, DateTimeOffset.FromUnixTimeSeconds(endTime));
 
-            // Method 2: Parse contract data
-            //   structure is (from explorer source code)
-            // ;; uint256 index
-            // ;; MsgAddressInt collection_address
-            // ;; MsgAddressInt owner_address
-            // ;; cell content
-            // ;; cell domain -e.g contains "alice"(without ending \0) for "alice.ton" domain
-            // ;; cell auction - auction info
-            // ;; int last_fill_up_time
-            var data = await tonClient.SmcGetData(smc.Id);
+            // Method 1-bis: use TonRecipes to call 'get_auction_info' method.
+            var ai = await TonRecipes.RootDns.GetAuctionInfo(tonClient, domainAddress);
+            logger.LogInformation("Auction info (method 1-bis): last bid = {Value} TON, bidder is {Address}, auction ends at {Time}", ai!.MaxBidAmount, ai.MaxBidAddress, ai.AuctionEndTime);
 
-            var slice = data.ToBoc().RootCells[0].BeginRead();
+            // Method 2: Use TonRecipes to parse all DNS Item data.
+            var di = await TonRecipes.RootDns.GetAllInfo(tonClient, domainName);
+            logger.LogInformation("Auction info (method 2): last bid = {Value} TON, bidder is {Address}, auction ends at {Time}", di.AuctionInfo!.MaxBidAmount, di.AuctionInfo.MaxBidAddress, di.AuctionInfo.AuctionEndTime);
+        }
+
+        private async Task<(string name, string address)> FindDomainOnAuction()
+        {
+            // We need to check last IN transactions on ".ton DNS" address
+            var rootDnsAddress = "EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz";
 
-            // skip index
-            slice.SkipBits(256);
+            var rootDnsState = await tonClient.GetAccountState(rootDnsAddress);
+            var rootDnsTransactions = await tonClient.RawGetTransactions(rootDnsAddress, rootDnsState.LastTransactionId);
 
-            // load (and compare) collection address
-            var ca = slice.LoadAddressIntStd();
-            if (ca != dnsAddress.Value)
+            // Look for transaction with text comment
+            var dnsTx = rootDnsTransactions.TransactionsList.FirstOrDefault(x => x.InMsg != null && x.InMsg.MsgData is DataText dt && !string.IsNullOrEmpty(dt.Text));
+            if (dnsTx == null)
             {
-                throw new Exception("Address mismatch. Something went wrong...");
+                return (string.Empty, string.Empty);
             }
 
-            // owner address (usually empty, as auction is in progress)
-            slice.TryLoadAddressIntStd();
+            TonUtils.Text.TryDecodeBase64((dnsTx.InMsg!.MsgData as DataText)!.Text, out var domain);
+            domain += ".ton";
 
-            // skip Content cell for now
-            slice.LoadRef();
+            var domainAddress = dnsTx.OutMsgs![0].Destination;
+            var bid = TonUtils.Coins.FromNano(dnsTx.OutMsgs[0].Value);
 
-            // domain name is in second cell
-            var domainName2 = System.Text.Encoding.ASCII.GetString(slice.LoadRef().Content);
-            if (domainName2 != domain)
-            {
-                throw new Exception("Domain name mismatch. Something went wrong...");
-            }
+            logger.LogInformation("Last auction found: domain '{Name}' (address {Address}), last bid = {Value} TON, bidder is {Address}", domain, domainAddress.Value, bid, dnsTx.InMsg.Source.Value);
 
-            var aucinfo = slice.LoadDict().BeginRead();
-            var adr2 = aucinfo.LoadAddressIntStd();
-            var coins2 = aucinfo.LoadCoins();
-            var endTime2 = aucinfo.LoadLong();
-            logger.LogInformation("Auction info (method 2): last bid = {Value} TON, bidder is {Address}, auction ends at {Time}", TonUtils.Coins.FromNano(coins2), adr2, DateTimeOffset.FromUnixTimeSeconds(endTime2));
+            return (domain, domainAddress.Value);
         }
     }
 }

TonLibDotNet.Demo/Samples/ResolveDomains.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Logging;
+using System.Text;
+using Microsoft.Extensions.Logging;
 using TonLibDotNet.Types.Dns;
 
 namespace TonLibDotNet.Samples
@@ -8,6 +9,13 @@ public class ResolveDomains
         private readonly ITonClient tonClient;
         private readonly ILogger logger;
 
+        // Values below may change over time. Verify them using explorers as first troubleshooting step.
+        private const string DomainName = "toncenter";
+        private const string DomainNameFull = "toncenter.ton";
+        private const string CollectionAddress = "EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz";
+        private const string DomainNftAddress = "EQAiIsvar4OYBn8BGBf9flfin6tl5poBx4MgJe4CQJYasy51";
+        private const string OwnerAddress = "EQCh-GaMveITkw41cHEvi13ZzAXNVtRksHq_PvGuMFENnhrT";
+
         public ResolveDomains(ITonClient tonClient, ILogger<ResolveDomains> logger)
         {
             this.tonClient = tonClient ?? throw new ArgumentNullException(nameof(tonClient));
@@ -25,14 +33,14 @@ public async Task Run(bool useMainnet)
             await tonClient.InitIfNeeded();
 
             // Method 1: use non-empty TTL
-            var res1 = await tonClient.DnsResolve("toncenter.ton", ttl: 9);
+            var res1 = await tonClient.DnsResolve(DomainNameFull, ttl: 9);
             var adnl1 = (res1.Entries[0].Value as EntryDataAdnlAddress)?.AdnlAddress.Value;
 
             // Method 2: Use zero TTL and recurse yourself
             var res2 = await tonClient.DnsResolve("ton", null, null, null);
             // Now we have NFT Collection (EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz) in 'NextResolver'
             // Let's ask it for next part
-            res2 = await tonClient.DnsResolve("toncenter", (res2.Entries[0].Value as EntryDataNextResolver).Resolver, null, null);
+            res2 = await tonClient.DnsResolve(DomainName, (res2.Entries[0].Value as EntryDataNextResolver).Resolver, null, null);
             // Now we have NFT itself (Contract Type = Domain, toncenter.ton, EQAiIsvar4OYBn8BGBf9flfin6tl5poBx4MgJe4CQJYasy51) in 'NextResolver'
             var nftAccountAddress = (res2.Entries[0].Value as EntryDataNextResolver).Resolver;
             // Let's ask it about actual ADNL of this domain
@@ -43,16 +51,51 @@ public async Task Run(bool useMainnet)
             logger.LogInformation("Results:\r\nADNL (method 1): {Val}\r\nADNL (method 2): {Val}", adnl1, adnl2);
 
             // Some experiments. Try TTL=1
-            var res3 = await tonClient.DnsResolve("toncenter.ton", null, 1);
+            var res3 = await tonClient.DnsResolve(DomainNameFull, null, 1);
             // We now have again 'EQAiIsvar4OYBn8BGBf9flfin6tl5poBx4MgJe4CQJYasy51' in 'NextResolver' !
             // You see? TTL is a number of 'recursive iterations' to 'NextResolvers' that is performed by LiteServer itself.
             // Checking with TTL=2, we should receive final ADNL record:
-            var res4 = await tonClient.DnsResolve("toncenter.ton", null, 2);
+            var res4 = await tonClient.DnsResolve(DomainNameFull, null, 2);
             var adnl4 = (res4.Entries[0].Value as EntryDataAdnlAddress)?.AdnlAddress.Value; // Yes, we do!
 
-            // Unfortunately, asking for account state of NFT itself returns raw.AccountState, not Dns.AccountState, I don't know why :(
-            _ = await tonClient.GetAccountState(nftAccountAddress);
-            // But check ReadInfoFromSmartContracts() to know how to get owner of this NFT!
+            // and get records
+            var entries = await TonRecipes.RootDns.GetEntries(tonClient, nftAccountAddress.Value);
+            logger.LogInformation("Wallet:        {Value}", entries.Wallet);
+            logger.LogInformation("Storage:       {Value}", entries.Storage);
+            logger.LogInformation("Site (ADNL):   {Value}", entries.SiteToAdnl);
+            logger.LogInformation("Site (Storage):{Value}", entries.SiteToStorage);
+            logger.LogInformation("Next Resolver: {Value}", entries.DnsNextResolver);
+
+
+            // Method 3: Use TonRecipes and recieve all info with one call
+            var di = await TonRecipes.RootDns.GetAllInfo(tonClient, DomainNameFull);
+
+            logger.LogInformation("TonRecipes info for '{Domain}':", di.Name);
+            logger.LogInformation("  Collection is: {Value}", di.CollectionAddress);
+            logger.LogInformation("  Index is:      {Value}", Convert.ToBase64String(di.Index));
+            logger.LogInformation("  NFT address:   {Value}", di.Address);
+            logger.LogInformation("  Deployed?:     {Value}", di.IsDeployed);
+
+            if (di.IsDeployed)
+            {
+                logger.LogInformation("  Owner:         {Value}", di.EditorAddress);
+                logger.LogInformation("  In auction:    {Value}", di.AuctionInfo != null);
+                if (di.AuctionInfo != null)
+                {
+                    logger.LogInformation("      Max Bid:    {Value}", di.AuctionInfo.MaxBidAmount);
+                    logger.LogInformation("      Max Bidder: {Value}", di.AuctionInfo.MaxBidAddress);
+                    logger.LogInformation("      End time:   {Value}", di.AuctionInfo.AuctionEndTime);
+                }
+
+                logger.LogInformation("  Last fill-up:  {Value}", di.LastFillUpTime);
+
+                logger.LogInformation("  DNS Entries:");
+                logger.LogInformation("    Wallet:     {Value}", di.Entries.Wallet);
+                logger.LogInformation("    Site (ADNL):{Value}", di.Entries.SiteToAdnl);
+                logger.LogInformation("    Site (Stor):{Value}", di.Entries.SiteToStorage);
+                logger.LogInformation("    Storage:    {Value}", di.Entries.Storage);
+                logger.LogInformation("    Next resolv:{Value}", di.Entries.DnsNextResolver);
+            }
         }
     }
 }

TonLibDotNet/Recipes/RootDnsRecipes.cs

@@ -0,0 +1,51 @@
+namespace TonLibDotNet.Recipes
+{
+    /// <remarks>
+    /// Based on <see href="https://github.com/ton-blockchain/TEPs/blob/master/text/0081-dns-standard.md">TEP 81: TON DNS Standard</see>
+    ///   and <see href="https://github.com/ton-blockchain/dns-contract">TON DNS Smart Contracts</see>.
+    /// </remarks>
+    public partial class RootDnsRecipes
+    {
+        /// <remarks>
+        /// TL-B: <code>dns_smc_address#9fd3 smc_addr:MsgAddressInt flags:(## 8) { flags &lt;= 1 } cap_list:flags . 0?SmcCapList = DNSRecord</code>
+        /// </remarks>
+        private const ushort DnsEntryTypeWallet = 0x9fd3;
+
+        /// <remarks>
+        /// TL-B: <code>dns_next_resolver#ba93 resolver:MsgAddressInt = DNSRecord</code>
+        /// </remarks>
+        private const ushort DnsEntryTypeNextDnsResolver = 0xba93;
+
+        /// <remarks>
+        /// TL-B: <code>dns_adnl_address#ad01 adnl_addr:bits256 flags:(## 8) { flags &lt;= 1 } proto_list:flags . 0?ProtoList = DNSRecord</code>
+        /// </remarks>
+        private const ushort DnsEntryTypeAdnl = 0xad01;
+
+        /// <remarks>
+        /// TL-B: <code>dns_storage_address#7473 bag_id:bits256 = DNSRecord</code>
+        /// </remarks>
+        private const ushort DnsEntryTypeStorageBagId = 0x7473;
+
+        private const string CategoryNameSite = "site";
+        private const string CategoryNameWallet = "wallet";
+        private const string CategoryNameStorage = "storage";
+        private const string CategoryNameNextDnsResolver = "dns_next_resolver";
+
+        private static readonly byte[] CategoryBytesSite = EncodeCategory(CategoryNameSite);
+        private static readonly byte[] CategoryBytesWallet = EncodeCategory(CategoryNameWallet);
+        private static readonly byte[] CategoryBytesStorage = EncodeCategory(CategoryNameStorage);
+        private static readonly byte[] CategoryBytesNextDnsResolver = EncodeCategory(CategoryNameNextDnsResolver);
+
+        /// <summary>
+        /// From <see href="https://github.com/ton-blockchain/dns-contract/blob/main/func/dns-utils.fc">dns-utils.fc</see>
+        /// </summary>
+        private const int OPChangeDnsRecord = 0x4eb1f0f9;
+
+        public static readonly RootDnsRecipes Instance = new();
+
+        protected static byte[] EncodeCategory(string categoryName)
+        {
+            return System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.ASCII.GetBytes(categoryName));
+        }
+    }
+}