Oda/managing-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

GMX v2 - Trading (#7)

Browse Source 
* Move PrivateKeys.cs

* Update gitignore

* Update gitignore

* updt

* Extract GmxServiceTests.cs

* Refact

* update todo

* Update code

* Fix hashdata

* Replace static token hashed datas

* Set allowance

* Add get orders

* Add get orders tests

* Add ignore

* add close orders

* revert

* Add get gas limit

* Start increasePosition. Todo: Finish GetExecutionFee and estimateGas

* little refact

* Update gitignore

* Fix namespaces and clean repo

* Add tests samples

* Add execution fee

* Add increase position

* Handle backtest on the frontend

* Add tests

* Update increase

* Test increase

* fix increase

* Fix size

* Start get position

* Update get positions

* Fix get position

* Update rpc and trade mappers

* Finish close position

* Fix leverage
This commit is contained in:
Oda
2025-01-30 23:06:22 +07:00
committed by GitHub
parent ecaa89c67b
commit 65bdb8e34f
156 changed files with 11253 additions and 4073 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
src/Managing.Infrastructure.Tests/ExchangeServicesTests.cs
View File

@@ -1,23 +1,22 @@
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.Repositories;
using Managing.Application.Abstractions.Services;
using Managing.Domain.Candles;
using Managing.Domain.Trades;
using Managing.Infrastructure.Evm;
using Managing.Infrastructure.Evm.Abstractions;
using Managing.Infrastructure.Exchanges;
using Managing.Infrastructure.Exchanges.Abstractions;
using Managing.Infrastructure.Exchanges.Exchanges;
using Managing.Infrastructure.Evm;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Xunit;
using static Managing.Common.Enums;
using Ticker = Managing.Common.Enums.Ticker;
using Managing.Infrastructure.Evm.Abstractions;
namespace Managing.Infrastructure.Tests
{
public class ExchangeServicesTests
public class ExchangeServicesTests
{
private readonly IExchangeService _exchangeService;
public readonly string PublicAddress = "";
@@ -26,8 +25,7 @@ namespace Managing.Infrastructure.Tests
public ExchangeServicesTests()
{
ILoggerFactory doesntDoMuch = new Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory();
ILoggerFactory doesntDoMuch = new NullLoggerFactory();
var candleRepository = new Mock<ICandleRepository>().Object;
var evmManager = new EvmManager(Subgraphs);
var evmProcessor = new EvmProcessor(new Mock<ILogger<EvmProcessor>>().Object, evmManager);
@@ -36,24 +34,25 @@ namespace Managing.Infrastructure.Tests
evmProcessor
};
_exchangeService = new ExchangeService(doesntDoMuch.CreateLogger<ExchangeService>(), candleRepository, exchangeProcessors);
_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)
[InlineData(TradingExchanges.Evm, Ticker.BTC)]
public void Should_Return_Price_For_Given_Ticker(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.ADA)]
public void Should_Return_Candle_For_Given_Ticker(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
var candle = _exchangeService.GetCandle(account, ticker, DateTime.Now);
Assert.IsType<Candle>(candle);
Assert.InRange(candle.High, 0, 1000000);
@@ -63,138 +62,124 @@ namespace Managing.Infrastructure.Tests
}
[Theory]
[InlineData(Enums.TradingExchanges.Evm)]
public void Should_Return_Balance(Enums.TradingExchanges exchange)
[InlineData(TradingExchanges.Evm)]
public void Should_Return_Balance(TradingExchanges exchange)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, "0x2875673415c66bf05091eeff3887e0d40136d5ea443a4e63e7f4e41a6580575e",
Ticker.BTC)]
public void Should_Return_Trade_For_Given_OrderId(TradingExchanges exchange, string orderId,
Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.BTC)]
public void Should_Return_List_Of_Candle_Given_Ticker(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var candles = _exchangeService.GetCandles(account, ticker, DateTime.Now.AddDays(-10), Timeframe.OneDay).Result;
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.ADA, "7INRiu79cv2nCONNlILPu0")]
public void Should_Return_Long_Trade(TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.ADA, "AQKzJpDNrfVjuq81baPLfR")]
public void Should_Return_Short_Trade(TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.BTC)]
public async void Should_Return_Balance_For_Ticker(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.ADA)]
public void Should_Return_Trade_List_For_Ticker(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm)]
public void Should_Return_Fee(TradingExchanges exchange)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.BTC)]
public void Should_Return_Volume(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)
[InlineData(TradingExchanges.Evm, Ticker.BTC)]
public async void Should_Return_Open_Order(TradingExchanges exchange, Ticker ticker)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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)]
[InlineData(TradingExchanges.Evm, Ticker.BTC, 0.1, TradeDirection.Long)]
[InlineData(TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Long)]
[InlineData(TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Short)]
public void Should_Return_Best_Price(
Enums.TradingExchanges exchange,
TradingExchanges exchange,
Ticker ticker,
decimal quantity,
TradeDirection direction)
{
var account = GetAccount(exchange);
var account = PrivateKeys.GetAccount();
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;
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;
}
}
}
}