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);
+    }
+}