docker files fixes from liaqat

src/Managing.Infrastructure.Tests/EvmManagerTests.cs

@@ -0,0 +1,379 @@
+using Managing.Application.Abstractions.Repositories;
+using Managing.Common;
+using Managing.Domain.Accounts;
+using Managing.Domain.Evm;
+using Managing.Domain.Trades;
+using Managing.Infrastructure.Evm;
+using Managing.Infrastructure.Evm.Abstractions;
+using Managing.Infrastructure.Evm.Models.Gmx;
+using Managing.Infrastructure.Evm.Referentials;
+using Managing.Infrastructure.Evm.Services;
+using Managing.Infrastructure.Evm.Services.Gmx;
+using Nethereum.Contracts;
+using Nethereum.Contracts.Standards.ERC721.ContractDefinition;
+using Nethereum.Web3;
+using System.Numerics;
+using Xunit;
+using static Managing.Common.Enums;
+
+namespace Managing.Infrastructure.Tests;
+
+
+public class EvmManagerTests 
+{
+    private readonly IEvmManager _manager;
+    private readonly List<Domain.Evm.Chain>  _chains;
+
+    public List<ISubgraphPrices> Subgraphs;
+    public readonly string PublicAddress = "";
+
+
+ public EvmManagerTests() 
+    {
+        _manager = new EvmManager(Subgraphs);
+        _chains = ChainService.GetChains();
+    }
+
+    [Fact]
+    public void Should_construct_manager()
+    {
+        var manager = new EvmManager(Subgraphs);
+        Assert.IsType<EvmManager>(manager);
+    }
+
+    [Theory]
+    [InlineData("")]
+    public async void Should_get_address_balance(string address)
+    {
+        var balance = await _manager.GetAddressBalance(address);
+        Assert.IsType<decimal>(balance);
+        Assert.True(balance > -1);
+    }
+
+    // Connect to nft contract
+    [Theory]
+    [InlineData("0x17f4BAa9D35Ee54fFbCb2608e20786473c7aa49f")]
+    public async void Should_return_holder_list_for_nft_collection(string contract)
+    {
+        var holders = await _manager.GetContractHolders(contract, DateTime.UtcNow.AddDays(-30));
+        Assert.IsType<List<Holder>>(holders);
+        Assert.True(holders.Any());
+    }
+
+    [Theory]
+    [InlineData("0xa435530d50d7D17Fd9fc6E1c897Dbf7C08E12d35", "0x17f4BAa9D35Ee54fFbCb2608e20786473c7aa49f")]
+    public async void Should_return_event_transfer_nft(string owner, string contract)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var holders = await manager.GetNftEvent(owner, contract);
+        Assert.IsType<List<EventLog<TransferEventDTO>>>(holders);
+        Assert.True(holders.Any());
+    }
+
+    [Fact]
+    public async void Should_return_date_of_block()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var date = await manager.GetBlockDate(38793245);
+        Assert.Equal(new DateTime(2022, 11, 17, 11, 15, 33), date);
+    }
+
+    [Fact]
+    public void Should_verify_message_sign()
+    {
+        var message = "Message to sign";
+        var address = "0x94618601FE6cb8912b274E5a00453949A57f8C1e";
+        var privateKey = "0x7580e7fb49df1c861f0050fae31c2224c6aba908e116b8da44ee8cd927b990b0";
+
+        var manager = new EvmManager(Subgraphs);
+
+        var signature = manager.SignMessage(message, privateKey);
+        var addressRecovered = manager.VerifySignature(signature, message);
+
+        Assert.Equal(addressRecovered, address);
+    }
+
+    [Fact]
+    public void Shoud_return_generated_evm_address()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var keys = manager.GenerateAddress();
+
+        Assert.IsType<(string Key, string Secret)>(keys);
+        Assert.False(string.IsNullOrEmpty(keys.Key));
+        Assert.False(string.IsNullOrEmpty(keys.Secret));
+    }
+
+    [Fact] 
+    public void Should_return_correct_account_for_mnemo()
+    {
+        var mnemo = "twist enemy flame exchange summer roast beyond friend image pyramid topple need";
+        var manager = new EvmManager(Subgraphs);
+        var publicAddress = "0x3aBAD913A70554f416944F1a4C0EAbF3BCAFB959";
+        var address = manager.GetAddressFromMnemo(mnemo);
+        Assert.NotNull(address);
+        Assert.IsType<string>(address);
+        Assert.Equal(publicAddress, address);
+    }
+
+    [Theory]
+    //[InlineData("0x0425dEAb364E9121F7CA284129dA854FD5cF22eD", Constants.Chains.Ethereum)]
+    [InlineData("0x7002AE0Bae7fC67416230F025A32EfE086C0934E", Constants.Chains.Arbitrum)]
+    public async void Should_return_balances(string publicAddress, string chainName)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var chain = _chains.First(c => c.Name == chainName);
+        var balances = await manager.GetBalances(chain, 0, 30, publicAddress);
+
+        Assert.IsType<List<EvmBalance>>(balances);
+        Assert.NotEmpty(balances);
+    }
+
+    [Theory]
+    //[InlineData("0x7002ae0bae7fc67416230f025a32efe086c0934e", Constants.Chains.Arbitrum)]
+    [InlineData("0xc62F5499789b716Aa94a421A60c76c8c13A31ab6", Constants.Chains.Ethereum)]
+    public async void Should_return_all_balance(string publicAddress, string chainName)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var chain = _chains.First(c => c.Name == chainName);
+        var balances = await manager.GetAllBalances(chain, publicAddress);
+
+        Assert.IsType<List<EvmBalance>>(balances);
+        Assert.True(balances.Count > 1);
+    }
+
+    [Theory]
+    [InlineData("", Constants.Chains.Arbitrum, Ticker.GMX)]
+    public async void Should_return_token_balance(string publicAddress, string chainName, Ticker ticker)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var balance = await manager.GetTokenBalance(chainName, ticker, publicAddress);
+
+        Assert.IsType<EvmBalance>(balance);
+        Assert.True(balance.Balance > 0);
+    }
+
+    [Theory]
+    [InlineData("")]
+    public async void Should_return_balance_of_ethers(string publicAddress)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var chain = _chains.First(c => c.Name == Constants.Chains.Ethereum);
+        var balance = await manager.GetEtherBalance(chain, publicAddress);
+
+        Assert.IsType<EvmBalance>(balance);
+    }
+
+    [Theory]
+    [InlineData("")]
+    public async void Should_return_all_balance_for_all_chain(string publicAddress)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var balances = await manager.GetAllBalancesOnAllChain(publicAddress);
+
+        Assert.IsType<List<EvmBalance>>(balances);
+        Assert.True(balances.Count > 0);
+    }
+
+    [Theory]
+    [InlineData(Ticker.BTC, Timeframe.FiveMinutes)]
+    public async void Get_Prices(Ticker ticker, Timeframe timeframe)
+    {
+        var manager = new EvmManager(Subgraphs);
+        var candles = await manager.GetCandles(SubgraphProvider.ChainlinkPrice, ticker, DateTime.UtcNow, timeframe);
+
+        if (candles == null || !candles.Any())
+        {
+            candles = await manager.GetCandles(SubgraphProvider.ChainlinkGmx, ticker, DateTime.UtcNow, timeframe);
+        }
+        Assert.NotNull(candles);
+        Assert.True(candles.Any());
+    }
+
+    [Fact]
+    public async void Get_Available_Tickers()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var tickers = await manager.GetAvailableTicker();
+
+        Assert.NotEmpty(tickers);
+    }
+
+    [Fact]
+    public async void GetLastCandle()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var candle = await manager.GetCandle(SubgraphProvider.Gbc, Ticker.BTC);
+
+        Assert.NotNull(candle);
+    }
+
+    [Fact]
+    public async void Should_Init_Address_For_Trading()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var accountInitilized = await manager.InitAddress(Constants.Chains.Arbitrum, PublicAddress, "PrivateKey");
+
+        Assert.True(accountInitilized);
+    }
+
+    [Fact]
+    public async void Should_send_eth_from_account()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var chain = _chains.First(c => c.Name == Constants.Chains.Arbitrum);
+        var balance = await manager.GetEtherBalance(chain, PublicAddress);
+        // Update receiver
+        var receiverAddress = "";
+        var sendResult = await manager.Send(
+            chain,
+            Ticker.ETH,
+            balance.Balance / 2,
+            PublicAddress,
+            "",
+            receiverAddress);
+
+        Assert.True(sendResult);
+    }
+
+    [Fact]
+    public async void Should_send_Gmx_from_account()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var chain = _chains.First(c => c.Name == Constants.Chains.Arbitrum);
+        var receiverAddress = "";
+        var balance = await manager.GetTokenBalance(chain.Name, Ticker.GMX, PublicAddress);
+
+        var sendResult = await manager.Send(
+            chain,
+            Ticker.GMX,
+            balance.Balance / 2,
+            PublicAddress, 
+            "",
+            receiverAddress);
+
+        Assert.True(sendResult);
+    }
+
+    [Fact]
+    public async void Should_return_indexes_from_gmx()
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var indexes = await GmxService.GetLastIndex(web3, "");
+
+        Assert.IsType<GmxOrderIndexes>(indexes);
+    }
+
+    [Theory]
+    [InlineData("")]
+    public async void Should_return_gmx_orders(string publicAddress)
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var orders = await GmxService.GetOrders(web3, publicAddress, Ticker.BTC);
+        
+        Assert.IsType<List<GmxOrder>>(orders);
+    }
+
+    [Fact]
+    public async void Should_return_orders()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var account = GetAccount();
+
+        var orders = await manager.GetOrders(account, Ticker.BTC);
+
+        Assert.IsType<List<Trade>>(orders);
+    }
+
+    [Fact]
+    public async void Should_cancel_gmx_orders()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var account = GetAccount();
+
+        var cancelled = await manager.CancelOrders(account, Ticker.BTC);
+
+        Assert.IsType<bool>(cancelled);
+    }
+
+    private static Account GetAccount()
+    {
+        return new Account
+        {
+            Key = "PublicAddress",
+            Secret = "PrivateKey"
+        };
+    }
+
+    [Fact]
+    public void Should_convert_quantity()
+    {
+        var quantity = Web3.Convert.ToWei(0.0019);
+
+        Assert.IsType<BigInteger>(quantity);
+    }
+
+    [Fact]
+    public async void Should_approve_order()
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var approval = await GmxService.ApproveOrder(web3, Ticker.BTC, PublicAddress, 0.0003m);
+
+        Assert.IsType<bool>(approval);
+    }
+
+    [Fact]
+    public async void Should_check_approved_gmx_plugin()
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var isPluginAdded = await GmxService.IsPluginAdded(web3, "", Arbitrum.Address.OrderBook);
+
+        Assert.IsType<bool>(isPluginAdded);
+        Assert.True(isPluginAdded);
+    }
+
+    [Fact]
+    public void Should_return_correct_acceptable_price()
+    {
+        var acceptablePrice = GmxHelpers.GetAcceptablePrice(16672.76m, true);
+        var price = new BigInteger(1662274172);
+        var expected = Web3.Convert.ToWei(price, 25);
+
+        Assert.NotNull(acceptablePrice);
+        Assert.IsType<BigInteger>(acceptablePrice);
+        Assert.Equal(expected, acceptablePrice);
+    }
+
+    [Fact]
+    public async void Should_return_quantity_in_position()
+    {
+        var manager = new EvmManager(Subgraphs);
+        var quantity = await manager.QuantityInPosition(Constants.Chains.Arbitrum, PublicAddress, Ticker.BTC);
+
+        Assert.NotNull(quantity);
+    }
+
+    [Fact]
+    public async void Should_return_Gmx_position()
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var position = await GmxService.GetGmxPosition(web3, "", Ticker.BTC);
+
+        Assert.IsType<GmxPosition>(position);
+    }
+
+    [Fact]
+    public async void Should_return_Trade()
+    {
+        var chain = ChainService.GetChain(Constants.Chains.Arbitrum);
+        var web3 = new Web3(chain.RpcUrl);
+        var position = await GmxService.GetTrade(web3, "", Ticker.ETH);
+
+        Assert.IsType<Trade>(position);
+    }
+}

src/Managing.Infrastructure.Tests/ExchangeServicesTests.cs

@@ -0,0 +1,200 @@
+using Managing.Common;
+using Managing.Domain.Trades;
+using Managing.Infrastructure.Exchanges;
+using Microsoft.Extensions.Logging;
+using Managing.Domain.Candles;
+using Xunit;
+using static Managing.Common.Enums;
+using Managing.Domain.Accounts;
+using Moq;
+using Managing.Application.Abstractions.Repositories;
+using Managing.Application.Abstractions.Services;
+using Managing.Infrastructure.Exchanges.Abstractions;
+using Managing.Infrastructure.Exchanges.Exchanges;
+using Managing.Infrastructure.Evm;
+using Ticker = Managing.Common.Enums.Ticker;
+using Managing.Infrastructure.Evm.Abstractions;
+
+namespace Managing.Infrastructure.Tests
+{
+    public class ExchangeServicesTests 
+    {
+        private readonly IExchangeService _exchangeService;
+        public readonly string PublicAddress = "";
+
+        public List<ISubgraphPrices> Subgraphs;
+
+        public ExchangeServicesTests()
+        {
+
+            ILoggerFactory doesntDoMuch = new Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory();
+            var candleRepository = new Mock<ICandleRepository>().Object;
+            var evmManager = new EvmManager(Subgraphs);
+            var evmProcessor = new EvmProcessor(new Mock<ILogger<EvmProcessor>>().Object, evmManager);
+            var exchangeProcessors = new List<IExchangeProcessor>()
+            {
+                evmProcessor
+            };
+
+            _exchangeService = new ExchangeService(doesntDoMuch.CreateLogger<ExchangeService>(), candleRepository, exchangeProcessors);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_Price_For_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var price = _exchangeService.GetPrice(account, ticker, DateTime.Now);
+            Assert.IsType<decimal>(price);
+            Assert.InRange(price, 0, 1000000);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA)]
+        public void Should_Return_Candle_For_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var candle = _exchangeService.GetCandle(account, ticker, DateTime.Now);
+            Assert.IsType<Candle>(candle);
+            Assert.InRange(candle.High, 0, 1000000);
+            Assert.InRange(candle.Low, 0, 1000000);
+            Assert.InRange(candle.Open, 0, 1000000);
+            Assert.InRange(candle.Close, 0, 1000000);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm)]
+        public void Should_Return_Balance(Enums.TradingExchanges exchange)
+        {
+            var account = GetAccount(exchange);
+            var balance = _exchangeService.GetBalance(account).Result;
+            Assert.IsType<decimal>(balance);
+            Assert.True(balance >= 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, "0x2875673415c66bf05091eeff3887e0d40136d5ea443a4e63e7f4e41a6580575e", Ticker.BTC)]
+        public void Should_Return_Trade_For_Given_OrderId(Enums.TradingExchanges exchange, string orderId, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, orderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_List_Of_Candle_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var candles = _exchangeService.GetCandles(account, ticker, DateTime.Now.AddDays(-10), Timeframe.OneDay).Result;
+            Assert.IsType<List<Candle>>(candles);
+            Assert.InRange(candles.Count, 1, 15);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA, "7INRiu79cv2nCONNlILPu0")]
+        public void Should_Return_Long_Trade(Enums.TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, exchangeOrderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+            Assert.True(trade.Direction == TradeDirection.Long);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA, "AQKzJpDNrfVjuq81baPLfR")]
+        public void Should_Return_Short_Trade(Enums.TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, exchangeOrderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+            Assert.True(trade.Direction == TradeDirection.Short);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public async void Should_Return_Balance_For_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var balance = await _exchangeService.GetQuantityInPosition(account, ticker);
+            Assert.IsType<decimal>(balance);
+            Assert.True(balance > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA)]
+        public void Should_Return_Trade_List_For_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trades = _exchangeService.GetTrades(account, ticker).Result;
+            Assert.IsType<List<Trade>>(trades);
+            Assert.True(trades.Count > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm)]
+        public void Should_Return_Fee(Enums.TradingExchanges exchange)
+        {
+            var account = GetAccount(exchange);
+            var fee = _exchangeService.GetFee(account);
+            Assert.IsType<decimal>(fee);
+            Assert.True(fee > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_Volume(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var volume = _exchangeService.GetVolume(account, ticker);
+            Assert.IsType<decimal>(volume);
+            Assert.True(volume > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public async void Should_Return_Open_Order(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trades = await _exchangeService.GetOpenOrders(account, ticker);
+            Assert.IsType<List<Trade>>(trades);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 0.1, TradeDirection.Long)]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Long)]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Short)]
+        public void Should_Return_Best_Price(
+            Enums.TradingExchanges exchange,
+            Ticker ticker,
+            decimal quantity,
+            TradeDirection direction)
+        {
+            var account = GetAccount(exchange);
+            var lastPrice = _exchangeService.GetPrice(account, ticker, DateTime.UtcNow);
+            var bestPrice = _exchangeService.GetBestPrice(account, ticker, lastPrice, quantity, direction);
+
+            Assert.IsType<decimal>(bestPrice);
+
+            var percentageDiff = ( (bestPrice * 100) / lastPrice) - 100; 
+            Assert.True(Math.Abs(percentageDiff) < 1);
+        }
+
+        private Account GetAccount(Enums.TradingExchanges exchange)
+        {
+            var account = new Account();
+            switch (exchange)
+            {
+                case Enums.TradingExchanges.Evm:
+                    account.Exchange = Enums.TradingExchanges.Evm;
+                    account.Key = PublicAddress;
+                    account.Secret = "PrivateKey";
+                    account.Name = "EvmAccount";
+                    break;
+                default:
+                    break;
+            }
+            return account;
+        }
+    }
+}

src/Managing.Infrastructure.Tests/Managing.Infrastructure.Tests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	  <TargetFramework>net7.0</TargetFramework>
+	  <ImplicitUsings>enable</ImplicitUsings>
+	  <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
+    <PackageReference Include="Microsoft.TestPlatform.TestHost" Version="17.7.0" />
+    <PackageReference Include="Moq" Version="4.18.4" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
+    <PackageReference Include="xunit" Version="2.5.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Managing.Infrastructure.Exchanges\Managing.Infrastructure.Exchanges.csproj" />
+    <ProjectReference Include="..\Managing.Infrastructure.Web3\Managing.Infrastructure.Evm.csproj" />
+  </ItemGroup>
+
+</Project>

src/Managing.Infrastructure.Tests/SubgraphTests.cs

@@ -0,0 +1,56 @@
+using Xunit;
+using static Managing.Common.Enums;
+
+namespace Managing.Infrastructure.Tests;
+
+public class SubgraphTests 
+{
+    public SubgraphTests() 
+    {
+    }
+
+    // [Fact]
+    // public async void Should_get_price_from_chainlink_gmx()
+    // {
+    //     var prices = await ChainlinkGmx.GetPrices(Ticker.BTC, DateTime.UtcNow.AddDays(-4), Timeframe.FiveMinutes);
+
+    //     Assert.NotNull(prices);
+    //     Assert.True(prices.Any());
+    // }
+
+    // [Fact]
+    // public async void Should_get_price_from_gbc()
+    // {
+    //     var prices = await GbcFeed.GetPrices(Ticker.BTC, DateTime.UtcNow.AddDays(-15), Timeframe.FiveMinutes);
+
+    //     Assert.NotNull(prices);
+    //     Assert.True(prices.Any());
+    // }
+
+    // [Fact]
+    // public async void Should_get_price_from_chainlink()
+    // {
+    //     var prices = await Chainlink.GetPrices(Ticker.BTC, DateTime.UtcNow.AddDays(-4), Timeframe.FiveMinutes);
+
+    //     Assert.NotNull(prices);
+    //     Assert.True(prices.Any());
+    // }
+
+    // [Fact]
+    // public async void Should_get_top_tokens()
+    // {
+    //     var top = await Uniswap.GetTopTokens();
+
+    //     Assert.NotNull(top);
+    //     Assert.True(top.Tokens.Any());
+    // }
+
+    // [Fact]
+    // public async void Should_get_available_pairs_for_chainlink()
+    // {
+    //     var pairs = await Chainlink.GetTickers();
+
+    //     Assert.NotNull(pairs);
+    //     Assert.True(pairs.Any());
+    // }
+}

src/Managing.Infrastructure.Tests/TradaoTests.cs

@@ -0,0 +1,24 @@
+using Managing.Domain.Shared.Helpers;
+using Managing.Infrastructure.Evm.Services;
+using Xunit;
+
+namespace Managing.Infrastructure.Tests;
+
+public class TradaoTests
+{
+    [Fact]
+    public async void Should_return_best_trader() 
+    {
+        var service = new TradaoService();
+        var details = await service.GetBestTrader();
+        Assert.NotNull(details);
+    }
+
+    [Fact]
+    public async void Should_return_bad_trader()
+    {
+        var service = new TradaoService();
+        var details = (await service.GetBadTrader()).FindBadTrader();
+        Assert.NotNull(details);
+    }
+}