add Defi 0.1.0 | fix Core 0.3.4 (continuation-team#104)

* GITBOOK-35: No subject

* GITBOOK-36: No subject

* Add StackItem parsing | Client 0.3.2

* implement JettonMinter.cs

* Add NftCollection.cs

* GITBOOK-37: No subject

* update TonSdk.Contracts.csproj

* GITBOOK-38: No subject

* GITBOOK-39: No subject

* GITBOOK-40: No subject

* add sse client cancelation on disconnect

* added tg wallet support

* GITBOOK-42: No subject

* update deps version

* Update Transformers.cs continuation-team#86 (continuation-team#87)

Co-authored-by: Purple Guy <89442150+purpleguy99@users.noreply.github.com>

* GITBOOK-45: No subject

* add TonCenter v3, TonWhales API

* remove console writeline

* make TonClient.cs disposable (continuation-team#90)

* change package version, fix stack item parsing

* improve: compatible with double types with more decimal places (continuation-team#98)

* chore: make KeyPair usage simpler and more robust (continuation-team#95)

* GITBOOK-46: No subject

* add TonSdk.DeFi

---------

Co-authored-by: vlad013 <53117013+vlad013@users.noreply.github.com>
Co-authored-by: Daniel <89273037+7645re@users.noreply.github.com>
Co-authored-by: witter-deland <87846830+witter-deland@users.noreply.github.com>

Author: 4 people

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Continuation Team
+Copyright (c) 2024 Continuation Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -27,6 +27,11 @@ Library to work with Ton Connect 2.0
 [![NuGet](https://img.shields.io/nuget/vpre/TonSdk.Adnl.svg)](https://www.nuget.org/packages/TonSdk.Adnl) \
 Library to work with Ton ADNL
 
+### [TonSdk.DeFi](https://www.nuget.org/packages/TonSdk.DeFi/)
+[![NuGet](https://img.shields.io/nuget/dt/TonSdk.Defi.svg)](https://www.nuget.org/packages/TonSdk.DeFi)
+[![NuGet](https://img.shields.io/nuget/vpre/TonSdk.DeFi.svg)](https://www.nuget.org/packages/TonSdk.DeFi) \
+Library to work with Ton DeFi`s
+
 ## Features and status
 
 - [x] Builder, Cell, Slice

TonSdk.Core/src/Coins.cs

@@ -1,20 +1,25 @@
 using System;
+using System.Diagnostics;
 using System.Globalization;
 using System.Numerics;
 using System.Text.RegularExpressions;
 
-namespace TonSdk.Core {
-    public class CoinsOptions {
+namespace TonSdk.Core
+{
+    public class CoinsOptions
+    {
         public bool IsNano { get; set; }
         public int Decimals { get; set; }
 
-        public CoinsOptions(bool IsNano = false, int Decimals = 9) {
+        public CoinsOptions(bool IsNano = false, int Decimals = 9)
+        {
             this.IsNano = IsNano;
             this.Decimals = Decimals;
         }
     }
 
-    public class Coins {
+    public class Coins
+    {
         private decimal Value { get; set; }
         private int Decimals { get; set; }
         private decimal Multiplier { get; set; }
@@ -24,24 +29,29 @@ public class Coins {
         /// </summary>
         /// <param name="value">The value of the coins.</param>
         /// <param name="options">Optional options for customizing the coins.</param>
-        public Coins(object value, CoinsOptions? options = null) {
+        public Coins(object value, CoinsOptions? options = null)
+        {
             bool isNano = false;
             int decimals = 9;
 
-            if (options != null) {
+            if (options != null)
+            {
                 isNano = options?.IsNano != null ? options.IsNano : false;
                 decimals = options?.Decimals != null ? options.Decimals : 9;
             }
 
-            var _value = value?.ToString().Replace(",", ".");
+            if (value is string valueStr)
+            {
+                value = valueStr.Replace(",", ".");
+            }
 
-            CheckCoinsType(_value);
+            CheckCoinsType(value);
             CheckCoinsDecimals(decimals);
 
-            decimal decimalValue = decimal.Parse(_value, new CultureInfo("en-US"));
-
+            TryConvertToDecimal(value, out decimal decimalValue);
             int digitsValue = GetDigitsAfterDecimalPoint(decimalValue);
-            if (digitsValue > decimals) {
+            if (digitsValue > decimals)
+            {
                 throw new Exception(
                     $"Invalid Coins value, decimals places \"{digitsValue}\" can't be greater than selected \"{decimals}\"");
             }
@@ -56,7 +66,8 @@ public Coins(object value, CoinsOptions? options = null) {
         /// </summary>
         /// <param name="coins">The Coins to add.</param>
         /// <returns>A new Coins instance with the sum of the values.</returns>
-        public Coins Add(Coins coins) {
+        public Coins Add(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
 
@@ -69,7 +80,8 @@ public Coins Add(Coins coins) {
         /// </summary>
         /// <param name="coins">The Coins to subtract.</param>
         /// <returns>A new Coins instance with the difference of the values.</returns>
-        public Coins Sub(Coins coins) {
+        public Coins Sub(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
 
@@ -82,7 +94,8 @@ public Coins Sub(Coins coins) {
         /// </summary>
         /// <param name="value">The value to multiply by.</param>
         /// <returns>A new Coins instance with the multiplied value.</returns>
-        public Coins Mul(object value) {
+        public Coins Mul(object value)
+        {
             CheckValue(value);
             CheckConvertibility(value);
 
@@ -97,7 +110,8 @@ public Coins Mul(object value) {
         /// </summary>
         /// <param name="value">The value to divide by.</param>
         /// <returns>A new Coins instance with the divided value.</returns>
-        public Coins Div(object value) {
+        public Coins Div(object value)
+        {
             CheckValue(value);
             CheckConvertibility(value);
 
@@ -112,7 +126,8 @@ public Coins Div(object value) {
         /// </summary>
         /// <param name="coins">The Coins to compare.</param>
         /// <returns>True if the values are equal, false otherwise.</returns>
-        public bool Eq(Coins coins) {
+        public bool Eq(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
             return Value == coins.Value;
@@ -123,7 +138,8 @@ public bool Eq(Coins coins) {
         /// </summary>
         /// <param name="coins">The Coins to compare.</param>
         /// <returns>True if the current value is greater, false otherwise.</returns>
-        public bool Gt(Coins coins) {
+        public bool Gt(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
             return Value > coins.Value;
@@ -134,7 +150,8 @@ public bool Gt(Coins coins) {
         /// </summary>
         /// <param name="coins">The Coins to compare.</param>
         /// <returns>True if the current value is greater or equal, false otherwise.</returns>
-        public bool Gte(Coins coins) {
+        public bool Gte(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
             return Value >= coins.Value;
@@ -145,7 +162,8 @@ public bool Gte(Coins coins) {
         /// </summary>
         /// <param name="coins">The Coins to compare.</param>
         /// <returns>True if the current value is less, false otherwise.</returns>
-        public bool Lt(Coins coins) {
+        public bool Lt(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
             return Value < coins.Value;
@@ -156,7 +174,8 @@ public bool Lt(Coins coins) {
         /// </summary>
         /// <param name="coins">The Coins to compare.</param>
         /// <returns>True if the current value is less or equal, false otherwise.</returns>
-        public bool Lte(Coins coins) {
+        public bool Lte(Coins coins)
+        {
             CheckCoins(coins);
             CompareCoinsDecimals(this, coins);
             return Value <= coins.Value;
@@ -190,7 +209,8 @@ public bool Lte(Coins coins) {
         /// Returns a string representation of the Coins value.
         /// </summary>
         /// <returns>A string representation of the Coins value.</returns>
-        public override string ToString() {
+        public override string ToString()
+        {
             decimal value = Value / Multiplier;
             string formattedValue = value.ToString("F" + Decimals);
 
@@ -203,66 +223,96 @@ public override string ToString() {
             return coins;
         }
 
-        private static void CheckCoinsType(object value) {
+        private static void CheckCoinsType(object value)
+        {
             if (IsValid(value) && IsConvertable(value)) return;
             if (IsCoins(value)) return;
 
             throw new Exception("Invalid Coins value");
         }
 
-        private static void CheckCoinsDecimals(int decimals) {
-            if (decimals < 0 || decimals > 18) {
+        private static void CheckCoinsDecimals(int decimals)
+        {
+            if (decimals < 0 || decimals > 18)
+            {
                 throw new Exception("Invalid decimals value, must be 0-18");
             }
         }
 
-        private static void CheckCoins(Coins value) {
+        private static void CheckCoins(Coins value)
+        {
             //if (IsCoins(value)) return;
             //throw new Exception("Invalid value");
         }
 
-        private static void CompareCoinsDecimals(Coins a, Coins b) {
-            if (a.Decimals != b.Decimals) {
+        private static void CompareCoinsDecimals(Coins a, Coins b)
+        {
+            if (a.Decimals != b.Decimals)
+            {
                 throw new Exception("Can't perform mathematical operation of Coins with different decimals");
             }
         }
 
-        private static void CheckValue(object value) {
+        private static void CheckValue(object value)
+        {
             if (IsValid(value)) return;
             throw new Exception("Invalid value");
         }
 
-        private static void CheckConvertibility(object value) {
+        private static void CheckConvertibility(object value)
+        {
             if (IsConvertable(value)) return;
 
             throw new Exception("Invalid value");
         }
 
-        private static bool IsValid(object value) {
+        private static bool IsValid(object value)
+        {
             return value is string || value is int || value is decimal || value is double || value is float ||
                    value is long;
         }
 
-        private static bool IsConvertable(object value) {
-            try {
-                decimal.Parse(value.ToString(), new CultureInfo("en-US"));
+        private static bool IsConvertable(object value)
+        {
+            return TryConvertToDecimal(value, out _);
+        }
+
+        private static bool TryConvertToDecimal(object value, out decimal result)
+        {
+            var strValue = value.ToString();
+            if (double.TryParse(strValue, NumberStyles.Float, CultureInfo.InvariantCulture,
+                    out var doubleValue))
+            {
+                result = (decimal)doubleValue;
                 return true;
             }
-            catch (Exception) {
-                return false;
+
+            if (decimal.TryParse(strValue, NumberStyles.Float, CultureInfo.InvariantCulture,
+                    out var decimalValue))
+            {
+                result = decimalValue;
+                return true;
             }
+
+            result = 0;
+            return false;
         }
 
-        private static bool IsCoins(object value) {
+
+        private static bool IsCoins(object value)
+        {
             return value is Coins;
         }
 
-        private static int GetDigitsAfterDecimalPoint(decimal number) {
+        private static int GetDigitsAfterDecimalPoint(decimal number)
+        {
             string[] parts = number.ToString(new CultureInfo("en-US")).Split('.');
-            if (parts.Length == 2) {
+            if (parts.Length == 2)
+            {
                 return parts[1].Length;
             }
-            else {
+            else
+            {
                 return 0;
             }
         }
@@ -273,7 +323,8 @@ private static int GetDigitsAfterDecimalPoint(decimal number) {
         /// <param name="value">The value in nano.</param>
         /// <param name="decimals">The number of decimal places.</param>
         /// <returns>A new Coins instance representing the value in nano.</returns>
-        public static Coins FromNano(object value, int decimals = 9) {
+        public static Coins FromNano(object value, int decimals = 9)
+        {
             CheckCoinsType(value);
             CheckCoinsDecimals(decimals);
 
@@ -284,14 +335,15 @@ public static Coins FromNano(object value, int decimals = 9) {
         /// Converts the value of the Coins instance to a BigInteger.
         /// </summary>
         /// <returns>A BigInteger representation of the value.</returns>
-        public BigInteger ToBigInt() {
+        public BigInteger ToBigInt()
+        {
             return new BigInteger(Value);
         }
-        
+
         /// <summary>
         /// Return the pointed value of the Coins instance in decimal.
         /// </summary>
         /// <returns>A Decimal representation of the value.</returns>
         public decimal ToDecimal() => Value / Multiplier;
     }
-}
+}

TonSdk.Core/src/TonSdk.Core.csproj

@@ -6,7 +6,7 @@
         <LangVersion>8.0</LangVersion>
         <RootNamespace>TonSdk.Core</RootNamespace>
         <PackageId>TonSdk.Core</PackageId>
-        <Version>0.3.3</Version>
+        <Version>0.3.4</Version>
         <Authors>Continuation Team</Authors>
         <PackageDescription>Core library with types and structures for TON Blockchain</PackageDescription>
         <RepositoryUrl>https://github.com/continuation-team/TonSdk.NET</RepositoryUrl>

TonSdk.Core/src/crypto/KeyPair.cs

@@ -1,21 +1,33 @@
-using Org.BouncyCastle.Crypto;
+using System;
+using Org.BouncyCastle.Crypto;
 using Org.BouncyCastle.Crypto.Parameters;
 using Org.BouncyCastle.Crypto.Signers;
 using TonSdk.Core.Boc;
 
-namespace TonSdk.Core.Crypto {
-    public class KeyPair {
+namespace TonSdk.Core.Crypto
+{
+    public class KeyPair
+    {
         private readonly byte[] _privateKey;
         private readonly byte[] _publicKey;
         public byte[] PrivateKey => _privateKey;
         public byte[] PublicKey => _publicKey;
 
-        public KeyPair(byte[] privateKey, byte[] publicKey) {
+        public KeyPair(byte[] privateKey, byte[] publicKey = null)
+        {
+            var privateKeyParams = new Ed25519PrivateKeyParameters(privateKey, 0);
+            var generatedPublicKey = privateKeyParams.GeneratePublicKey();
+            var encodedPublicKey = generatedPublicKey.GetEncoded();
+
+            if (encodedPublicKey != null && publicKey != encodedPublicKey)
+                throw new ArgumentException("Public key does not match the private key.");
+
             _privateKey = privateKey;
-            _publicKey = publicKey;
+            _publicKey = encodedPublicKey;
         }
 
-        private static byte[] SignDetached(byte[] hash, byte[] privateKey) {
+        private static byte[] SignDetached(byte[] hash, byte[] privateKey)
+        {
             Ed25519PrivateKeyParameters privateKeyParams = new Ed25519PrivateKeyParameters(privateKey, 0);
 
             ISigner signer = new Ed25519Signer();
@@ -33,11 +45,12 @@ private static byte[] SignDetached(byte[] hash, byte[] privateKey) {
         /// <param name="data">The Cell data to sign.</param>
         /// <param name="key">The key used for signing.</param>
         /// <returns>The signature of the hashed Cell data.</returns>
-        public static byte[] Sign(Cell data, byte[] key) {
+        public static byte[] Sign(Cell data, byte[] key)
+        {
             byte[] hash = data.Hash.ToBytes();
             byte[] signature = SignDetached(hash, key);
 
             return signature;
         }
     }
-}
+}

TonSdk.Core/test/Coins.test.cs

@@ -19,7 +19,8 @@ public void Test_ParsingExceptions()
         Assert.Throws<Exception>(() => new Coins(string.Empty), "Invalid value");
         Assert.Throws<Exception>(() => new Coins("cat"), "Invalid value");
         Assert.Throws<Exception>(() => new Coins("10.5d"), "Invalid value");
-        Assert.Throws<Exception>(() => new Coins(20.555, new CoinsOptions(false, 0)), "Invalid Coins value, decimals places \"3\" can't be greater than selected \"0\"");
+        Assert.Throws<Exception>(() => new Coins(20.555, new CoinsOptions(false, 0)),
+            "Invalid Coins value, decimals places \"3\" can't be greater than selected \"0\"");
     }
 
     [Test]
@@ -67,8 +68,10 @@ public void Test_CheckCoins()
         Assert.That(new Coins("10").IsNegative, Is.EqualTo(false));
         Assert.That(new Coins("10").IsPositive, Is.EqualTo(true));
         Assert.That(new Coins(0).IsZero, Is.EqualTo(true));
-        Assert.DoesNotThrow(() =>new Coins(10).ToBigInt());
-        Assert.That(new Coins("10,641462085").ToDecimal() == decimal.Parse("10,641462085"), Is.EqualTo(true));
+        Assert.DoesNotThrow(() => new Coins(10).ToBigInt());
+        var d1 = new Coins("10,641462085").ToDecimal();
+        var d2=decimal.Parse("10,641462085");
+        Assert.Equals(new Coins("10,641462085").ToDecimal() ,decimal.Parse("10,641462085") );
     }
 
     [Test]
@@ -145,4 +148,10 @@ public void Test_FromNanoCoins()
         Assert.That(Coins.FromNano(9007199254740992).ToString(), Is.EqualTo("9007199,254740992"));
         Assert.That(Coins.FromNano("9007199254740992").ToString(), Is.EqualTo("9007199,254740992"));
     }
-}
+
+    [Test]
+    public void Test_LittleDoubleNumber()
+    {
+        Assert.DoesNotThrow(() => { new Coins(0.00000001); });
+    }
+}

TonSdk.DeFi/DeDust/DeDustAsset.cs

@@ -0,0 +1,44 @@
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+
+namespace TonSdk.DeFi.DeDust
+{
+    public class DeDustAsset
+    {
+        private readonly DeDustAssetType _type;
+        private readonly Address? _address;
+
+        private DeDustAsset(DeDustAssetType type, Address? address = null)
+        {
+            _type = type;
+            _address = address;
+        }
+
+        public static DeDustAsset Native() =>
+            new DeDustAsset(DeDustAssetType.Native);
+    
+        public static DeDustAsset Jetton(Address minter) =>
+            new DeDustAsset(DeDustAssetType.Jetton, minter);
+
+        public Cell ToCell()
+        {
+            var builder = new CellBuilder();
+            switch (_type)
+            {
+                case DeDustAssetType.Native:
+                    builder
+                        .StoreUInt((uint)DeDustAssetType.Native, 4);
+                    break;
+                case DeDustAssetType.Jetton:
+                    builder
+                        .StoreUInt((uint)DeDustAssetType.Jetton, 4)
+                        .StoreInt(_address.GetWorkchain(), 8)
+                        .StoreBytes(_address.GetHash());
+                    break;
+            }
+
+            return builder.Build();
+        }
+
+    }
+}

TonSdk.DeFi/DeDust/DeDustConstants.cs

@@ -0,0 +1,22 @@
+using TonSdk.Core;
+
+namespace TonSdk.DeFi.DeDust
+{
+    public class DeDustConstants
+    {
+        public static readonly Address MainNetFactory = new Address("EQBfBWT7X2BHg9tXAxzhz2aKiNTU1tpt5NsiK0uSDW_YAJ67");
+    }
+
+    public enum  DeDustAssetType 
+    {
+        Native = 0b0000,
+        Jetton = 0b0001,
+    }
+
+    public enum DeDustReadinessStatus 
+    {
+        NotDeployed,
+        NotReady,
+        Ready,
+    }
+}

TonSdk.DeFi/DeDust/DeDustFactory.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Threading.Tasks;
+using TonSdk.Client;
+using TonSdk.Client.Stack;
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+using TonSdk.DeFi.DeDust.Vault;
+
+namespace TonSdk.DeFi.DeDust
+{
+    public class DeDustFactory
+{
+    private readonly Address _address;
+
+    protected DeDustFactory(Address address)
+    {
+        _address = address;
+    }
+    
+    public Address Address => _address;
+    
+    public static DeDustFactory CreateFromAddress(Address address) 
+        => new DeDustFactory(address);
+    
+    private async Task<Address> GetPoolAddress(TonClient client, DeDustPoolType type, DeDustAsset[] assets)
+    {
+        if (assets.Length != 2)
+            throw new ArgumentException("Assets array length must be equal to 2.");
+
+        try
+        {
+            var result = await client.RunGetMethod(
+                _address,
+                "get_pool_address",
+                new IStackItem[]
+                {
+                    new VmStackInt((int)type),
+                    new VmStackSlice(assets[0].ToCell().Parse()),
+                    new VmStackSlice(assets[1].ToCell().Parse())
+                });
+            return ((Cell)result.Value.Stack[0]).Parse().ReadAddress();
+        }
+        catch
+        {
+            return await GetPoolAddress(client, type, assets);
+        }
+    }
+
+    public async Task<DeDustPool> GetPool(TonClient client, DeDustPoolType type, DeDustAsset[] assets)
+    {
+        var poolAddress = await GetPoolAddress(client, type, assets);
+        return DeDustPool.CreateFromAddress(poolAddress);
+    }
+    
+    private async Task<Address> GetVaultAddress(TonClient client, DeDustAsset asset)
+    {
+        try
+        {
+            var result = await client.RunGetMethod(
+                _address,
+                "get_vault_address",
+                new IStackItem[]
+                {
+                    new VmStackSlice()
+                    {
+                        Value = asset.ToCell().Parse()
+                    } 
+                });
+            return ((Cell)result.Value.Stack[0]).Parse().ReadAddress();
+        }
+        catch (Exception e)
+        {
+            return await GetVaultAddress(client, asset);
+        }
+    }
+    
+    public async Task<DeDustNativeVault> GetNativeVault(TonClient client)
+    {
+        var nativeVaultAddress = await GetVaultAddress(client, DeDustAsset.Native());
+        return DeDustNativeVault.CreateFromAddress(nativeVaultAddress);
+    }
+    
+    public async Task<DeDustJettonVault> GetJettonVault(TonClient client, Address address)
+    {
+        var jettonVaultAddress = await GetVaultAddress(client, DeDustAsset.Jetton(address));
+        return DeDustJettonVault.CreateFromAddress(jettonVaultAddress);
+    }
+}
+}

TonSdk.DeFi/DeDust/DeDustPool.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Numerics;
+using System.Threading.Tasks;
+using TonSdk.Client;
+using TonSdk.Client.Stack;
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+
+namespace TonSdk.DeFi.DeDust
+{
+    public class DeDustPool
+    {
+        private readonly Address _address;
+
+        protected DeDustPool(Address address)
+        {
+            _address = address;
+        }
+
+        public static DeDustPool CreateFromAddress(Address address)
+            => new DeDustPool(address);
+
+        public Address Address => _address;
+        
+        public async Task<DeDustReadinessStatus> GetReadinessStatus(TonClient client)
+        {
+            try
+            {
+                var state = (await client.GetAddressInformation(_address)).Value.State;
+                if(state != AccountState.Active)
+                    return DeDustReadinessStatus.NotDeployed;
+            
+                var reserves = await GetReserves(client);
+                return reserves[0] > BigInteger.Zero && reserves[1] > BigInteger.Zero 
+                    ? DeDustReadinessStatus.Ready 
+                    : DeDustReadinessStatus.NotReady;
+            }
+            catch (Exception e)
+            {
+                return await GetReadinessStatus(client);
+            }
+        }
+
+        private async Task<BigInteger[]> GetReserves(ITonClient client)
+        {
+            try
+            {
+                var result = await client.RunGetMethod(_address, "get_reserves", Array.Empty<IStackItem>());
+                return new []{ (BigInteger)result.Value.Stack[0], (BigInteger)result.Value.Stack[1]};
+            }
+            catch (Exception e)
+            {
+                return await GetReserves(client);
+            }
+            
+        }
+    }
+
+    public enum DeDustPoolType : int
+    {
+        Volatile = 0,
+        Stable = 1,
+    }
+}

TonSdk.DeFi/DeDust/Vault/DeDustJettonVault.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Numerics;
+using System.Threading.Tasks;
+using TonSdk.Client;
+using TonSdk.Client.Stack;
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+
+namespace TonSdk.DeFi.DeDust.Vault
+{
+    public class DeDustJettonVault
+    {
+        public static readonly uint DepositLiquidity = 0x40e108d6;
+        public static readonly uint Swap = 0xe3a0d482;
+    
+        private readonly Address _address;
+
+        protected DeDustJettonVault(Address address)
+        {
+            _address = address;
+        }
+    
+        public Address Address => _address;
+
+        public static DeDustJettonVault CreateFromAddress(Address address) 
+            => new DeDustJettonVault(address);
+    
+        public async Task<DeDustReadinessStatus> GetReadinessStatus(TonClient client)
+        {
+            try
+            {
+                var state = (await client.GetAddressInformation(_address)).Value.State;
+                if (state != AccountState.Active)
+                    return DeDustReadinessStatus.NotDeployed;
+        
+                var result = await client.RunGetMethod(_address, "is_ready", new IStackItem[] { });
+                return (int)(BigInteger)result.Value.Stack[0] == 0 
+                    ? DeDustReadinessStatus.NotReady 
+                    : DeDustReadinessStatus.Ready;
+            }
+            catch (Exception e)
+            {
+                return await GetReadinessStatus(client);
+            }
+        
+        }
+    
+        public static Cell CreateSwapPayload(DeDustJettonSwapOptions options)
+        {
+            return new CellBuilder()
+                .StoreUInt(Swap, 32)
+                .StoreAddress(options.PoolAddress)
+                .StoreUInt(0, 1)
+                .StoreCoins(options.Limit ?? new Coins(0))
+                .StoreOptRef(options.Next == null ? null : Utils.PackSwapSteps(options.Next))
+                .StoreRef(Utils.PackSwapParams(options.SwapParams ?? new DeDustSwapParams()))
+                .Build();
+        }
+    }
+}

TonSdk.DeFi/DeDust/Vault/DeDustNativeVault.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Threading.Tasks;
+using TonSdk.Client;
+using TonSdk.Contracts;
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+
+namespace TonSdk.DeFi.DeDust.Vault
+{
+    public class DeDustNativeVault
+    {
+        public static readonly uint DepositLiquidity = 0xd55e4686;
+        public static readonly uint Swap = 0xea06185d;
+    
+        private readonly Address _address;
+
+        protected DeDustNativeVault(Address address)
+        {
+            _address = address;
+        }
+    
+        public Address Address => _address;
+
+        public static DeDustNativeVault CreateFromAddress(Address address) 
+            => new DeDustNativeVault(address);
+    
+        public async Task<DeDustReadinessStatus> GetReadinessStatus(TonClient client)
+        {
+            try
+            {
+                var state = (await client.GetAddressInformation(_address)).Value.State;
+                return state != 
+                       AccountState.Active 
+                    ? DeDustReadinessStatus.NotDeployed 
+                    : DeDustReadinessStatus.Ready;
+            }
+            catch (Exception e)
+            {
+                return await GetReadinessStatus(client);
+            }
+        }
+
+        public static Cell CreateSwapBody(DeDustNativeSwapOptions options)
+        {
+            return new CellBuilder()
+                .StoreUInt(Swap, 32)
+                .StoreUInt(options.QueryId ?? SmcUtils.GenerateQueryId(60), 64)
+                .StoreCoins(options.Amount)
+                .StoreAddress(options.PoolAddress)
+                .StoreUInt(0, 1)
+                .StoreCoins(options.Limit ?? new Coins(0))
+                .StoreOptRef(options.Next == null ? null : Utils.PackSwapSteps(options.Next))
+                .StoreRef(Utils.PackSwapParams(options.SwapParams ?? new DeDustSwapParams()))
+                .Build();
+        }
+    }
+}

TonSdk.DeFi/DeDust/Vault/Utils.cs

@@ -0,0 +1,67 @@
+using TonSdk.Core;
+using TonSdk.Core.Boc;
+
+namespace TonSdk.DeFi.DeDust.Vault
+{
+    public class Utils
+    {
+        public static Cell? PackSwapParams(DeDustSwapParams swapParams)
+        {
+            return new CellBuilder()
+                .StoreUInt(swapParams.Deadline ?? 0, 32)
+                .StoreAddress(swapParams.RecipientAddress ?? null)
+                .StoreAddress(swapParams.RecipientAddress ?? null)
+                .StoreOptRef(swapParams.FulfillPayload ?? null)
+                .StoreOptRef(swapParams.RejectPayload ?? null)
+                .Build();
+        }
+    
+        public static Cell? PackSwapSteps(DeDustSwapStep[] swapSteps)
+        {
+            Cell? nextRef = null;
+            for (int i = swapSteps.Length - 1; i >= 0; i--)
+            {
+                nextRef = new CellBuilder()
+                    .StoreAddress(swapSteps[i].PoolAddress)
+                    .StoreUInt(0, 1)
+                    .StoreCoins(swapSteps[i].Limit ?? new Coins(0))
+                    .StoreOptRef(nextRef).Build();
+            }
+
+            return nextRef;
+        }
+    }
+
+    public struct DeDustJettonSwapOptions
+    {
+        public Address PoolAddress { get; set; }
+        public Coins? Limit { get; set; }
+        public DeDustSwapStep[]? Next { get; set; }
+        public DeDustSwapParams? SwapParams { get; set; }
+    }
+
+    public struct DeDustNativeSwapOptions
+    {
+        public ulong? QueryId { get; set; }
+        public Coins Amount { get; set; }
+        public Address PoolAddress { get; set; }
+        public Coins? Limit { get; set; }
+        public DeDustSwapStep[]? Next { get; set; }
+        public DeDustSwapParams? SwapParams { get; set; }
+    }
+
+    public struct DeDustSwapStep 
+    {
+        public Address PoolAddress { get; set; }
+        public Coins? Limit { get; set; }
+    }
+
+    public struct DeDustSwapParams
+    {
+        public uint? Deadline { get; set; }
+        public Address? RecipientAddress { get; set; }
+        public Address? ReferralAddress { get; set; }
+        public Cell? FulfillPayload { get; set; }
+        public Cell? RejectPayload { get; set; }
+    }
+}

TonSdk.DeFi/TonSdk.DeFi.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net6.0;net7.0;netstandard2.1</TargetFrameworks>
+        <ImplicitUsings>disable</ImplicitUsings>
+        <LangVersion>8.0</LangVersion>
+        <RootNamespace>TonSdk.DeFi</RootNamespace>
+        <PackageId>TonSdk.DeFi</PackageId>
+        <Version>0.1.0</Version>
+        <Authors>Continuation Team</Authors>
+        <PackageDescription>Library for work with popular TON DeFis.</PackageDescription>
+        <RepositoryUrl>https://github.com/continuation-team/TonSdk.NET</RepositoryUrl>
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <PackageReadmeFile>README.md</PackageReadmeFile>
+        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <None Include="../README.md" Pack="true" PackagePath="" />
+        <None Include="../LICENSE" Pack="true" PackagePath="" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+        <PackageReference Include="TonSdk.Client" Version="0.3.4" />
+        <PackageReference Include="TonSdk.Contracts" Version="0.3.1" />
+        <PackageReference Include="TonSdk.Core" Version="0.3.3" />
+    </ItemGroup>
+
+</Project>

TonSdk.NET.sln

@@ -21,6 +21,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TonSdk.Adnl", "TonSdk.Adnl\
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TonSdk.Adnl.Tests", "TonSdk.Adnl\test\TonSdk.Adnl.Tests.csproj", "{69DD2D24-5D2E-4B03-B3B3-D661AD4B335C}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TonSdk.DeFi", "TonSdk.DeFi\TonSdk.DeFi.csproj", "{B5C72F69-66CE-495F-8E5D-B61CE8AAE9BE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -63,6 +65,10 @@ Global
 		{69DD2D24-5D2E-4B03-B3B3-D661AD4B335C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{69DD2D24-5D2E-4B03-B3B3-D661AD4B335C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{69DD2D24-5D2E-4B03-B3B3-D661AD4B335C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B5C72F69-66CE-495F-8E5D-B61CE8AAE9BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B5C72F69-66CE-495F-8E5D-B61CE8AAE9BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B5C72F69-66CE-495F-8E5D-B61CE8AAE9BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B5C72F69-66CE-495F-8E5D-B61CE8AAE9BE}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

docs/.gitbook/assets/8f3dd4e-swaps.svg

@@ -23,6 +23,8 @@
   * [Wallet](user-manual/contracts/wallet/README.md)
     * [Wallet V3, V4](user-manual/contracts/wallet/wallet-v3-v4.md)
     * [Preprocessed V2](user-manual/contracts/wallet/preprocessed-v2.md)
+* [DeFi](user-manual/defi/README.md)
+  * [DeDust](user-manual/defi/dedust.md)
 * [Unity TonConnect 2.0](user-manual/unity-tonconnect-2.0/README.md)
   * [Getting Started](user-manual/unity-tonconnect-2.0/getting-started.md)
 * [Use cases](user-manual/use-cases/README.md)

docs/SUMMARY.md

@@ -0,0 +1,2 @@
+# DeFi
+

docs/user-manual/defi/README.md

@@ -0,0 +1,162 @@
+# DeDust
+
+{% hint style="info" %}
+For example, we will use `WalletV4`. You can find more examples for different contracts [here](https://docs.tonsdk.net/user-manual/contracts/wallet).
+{% endhint %}
+
+### Getting Started
+
+Initialize the SDK in your code using:
+
+```csharp
+Mnemonic mnemonic = new Mnemonic();
+WalletV4 wallet = new WalletV4(new WalletV4Options()
+{
+    PublicKey = mnemonic.Keys.PublicKey
+});
+
+TonClient tonClient = new TonClient(TonClientType.HTTP_TONCENTERAPIV2, new HttpParameters() {});
+DeDustFactory factory = DeDustFactory.CreateFromAddress(DeDustConstants.MainNetFactory);
+
+Address jettonAddress = new Address(/* here address of jetton master */); 
+```
+
+
+
+### Swapping TON to Jetton
+
+```csharp
+// define asset instances
+DeDustAsset nativeAsset = DeDustAsset.Native();
+DeDustAsset jettonAsset = DeDustAsset.Jetton(jettonAddress);
+
+// get actual pool of swap pair
+DeDustPool pool = await factory.GetPool(tonClient, DeDustPoolType.Volatile, new[] { nativeAsset, jettonAsset });
+
+// get native TON vault
+DeDustNativeVault tonVault = await factory.GetNativeVault(tonClient);
+
+// check if vault of TON exists
+if (await tonVault.GetReadinessStatus(tonClient) != DeDustReadinessStatus.Ready)
+{
+    Console.WriteLine("[Ton To Jetton] Vault (TON) does not exist.");
+    return;
+}
+
+// check if pool of swap pair exists
+if (await pool.GetReadinessStatus(tonClient) != DeDustReadinessStatus.Ready)
+{
+    Console.WriteLine("[Ton To Jetton] Pool (TON, Jetton) does not exist.");
+    return;
+}
+
+ // amount of TONs to swap
+double amount = 5;
+
+// create swap body cell
+Cell swapToJettonBody = DeDustNativeVault.CreateSwapBody(new DeDustNativeSwapOptions()
+{
+    PoolAddress = pool.Address,
+    Amount = new Coins(amount)
+});
+
+// getting seqno using tonClient
+uint? seqno = await tonClient.Wallet.GetSeqno(walletV4.Address);
+
+// create transfer message to vault contract
+var msg = wallet.CreateTransferMessage(new WalletTransfer[]
+{
+    new WalletTransfer
+    {
+        Message = new InternalMessage(new InternalMessageOptions
+        {
+            Info = new IntMsgInfo(new IntMsgInfoOptions
+            {
+                Dest = tonVault.Address,
+                Value = new Coins(amount).Add(new Coins(0.25)) // gas amount, dont change
+            }),
+            Body = swapToJettonBody
+        }),
+        Mode = 1
+    }
+}, seqno.Value).Sign(mnemonic.Keys.PrivateKey);
+
+// send signed message
+await tonClient.SendBoc(msg.Cell);
+```
+
+
+
+### Swapping Jetton to TON
+
+```csharp
+// get jetton wallet address 
+Address jettonWallet = await tonClient.Jetton.GetWalletAddress(jettonAddress, wallet.Address);
+
+// get jetton vault
+DeDustJettonVault jettonVault = await factory.GetJettonVault(tonClient, jettonAddress);
+
+// define asset instances
+DeDustAsset nativeAsset = DeDustAsset.Native();
+DeDustAsset jettonAsset = DeDustAsset.Jetton(jettonAddress);
+
+// get actual pool of swap pair
+DeDustPool pool = await factory.GetPool(tonClient, DeDustPoolType.Volatile, new[] { nativeAsset, jettonAsset });
+
+// check if vault of Jetton exists
+if (await jettonVault.GetReadinessStatus(Core.TonSecondClient) != DeDustReadinessStatus.Ready)
+{
+    Console.WriteLine("[Jetton To Ton] Vault (TON) does not exist.");
+    return;
+}
+
+// check if pool of swap pair exists
+if (await pool.GetReadinessStatus(Core.TonSecondClient) != DeDustReadinessStatus.Ready)
+{
+    Console.WriteLine("[Jetton To Ton] Pool (TON, Jetton) does not exist.");
+    return;
+}
+
+// jetton amount to swap
+double amount = 5;
+
+// create jetton transfer options
+JettonTransferOptions options = new JettonTransferOptions()
+{
+    Amount = new Coins(amount),
+    Destination = jettonVault.Address,
+    ResponseDestination = wallet.Address,
+    ForwardAmount = new Coins(0.25), // gas, dont change
+    ForwardPayload = DeDustJettonVault.CreateSwapPayload(new DeDustJettonSwapOptions()
+    {
+        PoolAddress = pool.Address
+    })
+};
+
+// create jetton tranfer cell
+Cell jettonTransfer = JettonWallet.CreateTransferRequest(options);
+
+// getting seqno using tonClient
+uint? seqno = await tonClient.Wallet.GetSeqno(walletV4.Address);
+
+// create transfer message to jetton wallet with swap body
+var msg = taskWallet.CreateTransferMessage(new WalletTransfer[]
+{
+    new WalletTransfer
+    {
+        Message = new InternalMessage(new InternalMessageOptions
+        {
+            Info = new IntMsgInfo(new IntMsgInfoOptions
+            {
+                Dest = jettonWallet,
+                Value = new Coins(0.3)
+            }),
+            Body = jettonTransfer
+        }),
+        Mode = 1
+    }
+}, seqno.Value).Sign(mnemonic.Keys.PrivateKey);
+
+// send signed message
+await tonClient.SendBoc(msg.Cell);
+```