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

168
src/Managing.Infrastructure.Tests/EvmManagerTests.cs
View File

@@ -1,34 +1,30 @@
using Managing.Application.Abstractions.Repositories;
using System.Numerics;
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 Microsoft.VisualStudio.TestTools.UnitTesting;
using Nethereum.Contracts;
using Nethereum.Contracts.Standards.ERC721.ContractDefinition;
using Nethereum.Web3;
using System.Numerics;
using Xunit;
using static Managing.Common.Enums;
using Assert = Xunit.Assert;
namespace Managing.Infrastructure.Tests;
public class EvmManagerTests
public class EvmManagerTests
{
private readonly IEvmManager _manager;
private readonly List<Domain.Evm.Chain> _chains;
private readonly List<Chain> _chains;
public List<ISubgraphPrices> Subgraphs;
public readonly string PublicAddress = "";
public EvmManagerTests()
public EvmManagerTests()
{
_manager = new EvmManager(Subgraphs);
_chains = ChainService.GetChains();
@@ -41,6 +37,7 @@ public class EvmManagerTests
Assert.IsType<EvmManager>(manager);
}
[Ignore]
[Theory]
[InlineData("")]
public async void Should_get_address_balance(string address)
@@ -51,6 +48,7 @@ public class EvmManagerTests
}
// Connect to nft contract
[Ignore]
[Theory]
[InlineData("0x17f4BAa9D35Ee54fFbCb2608e20786473c7aa49f")]
public async void Should_return_holder_list_for_nft_collection(string contract)
@@ -60,6 +58,7 @@ public class EvmManagerTests
Assert.True(holders.Any());
}
[Ignore]
[Theory]
[InlineData("0xa435530d50d7D17Fd9fc6E1c897Dbf7C08E12d35", "0x17f4BAa9D35Ee54fFbCb2608e20786473c7aa49f")]
public async void Should_return_event_transfer_nft(string owner, string contract)
@@ -70,6 +69,8 @@ public class EvmManagerTests
Assert.True(holders.Any());
}
[Ignore]
[Fact]
public async void Should_return_date_of_block()
{
@@ -104,7 +105,7 @@ public class EvmManagerTests
Assert.False(string.IsNullOrEmpty(keys.Secret));
}
[Fact]
[Fact]
public void Should_return_correct_account_for_mnemo()
{
var mnemo = "twist enemy flame exchange summer roast beyond friend image pyramid topple need";
@@ -116,19 +117,21 @@ public class EvmManagerTests
Assert.Equal(publicAddress, address);
}
[Ignore]
[Theory]
//[InlineData("0x0425dEAb364E9121F7CA284129dA854FD5cF22eD", Constants.Chains.Ethereum)]
[InlineData("0x7002AE0Bae7fC67416230F025A32EfE086C0934E", Constants.Chains.Arbitrum)]
[InlineData("0x0425dEAb364E9121F7CA284129dA854FD5cF22eD", Constants.Chains.Arbitrum)]
// [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);
var balances = await manager.GetBalances(chain, 0, 500, publicAddress);
Assert.IsType<List<EvmBalance>>(balances);
Assert.NotEmpty(balances);
}
[Ignore]
[Theory]
//[InlineData("0x7002ae0bae7fc67416230f025a32efe086c0934e", Constants.Chains.Arbitrum)]
[InlineData("0xc62F5499789b716Aa94a421A60c76c8c13A31ab6", Constants.Chains.Ethereum)]
@@ -142,6 +145,7 @@ public class EvmManagerTests
Assert.True(balances.Count > 1);
}
[Ignore]
[Theory]
[InlineData("", Constants.Chains.Arbitrum, Ticker.GMX)]
public async void Should_return_token_balance(string publicAddress, string chainName, Ticker ticker)
@@ -153,6 +157,7 @@ public class EvmManagerTests
Assert.True(balance.Balance > 0);
}
[Ignore]
[Theory]
[InlineData("")]
public async void Should_return_balance_of_ethers(string publicAddress)
@@ -164,6 +169,7 @@ public class EvmManagerTests
Assert.IsType<EvmBalance>(balance);
}
[Ignore]
[Theory]
[InlineData("")]
public async void Should_return_all_balance_for_all_chain(string publicAddress)
@@ -175,6 +181,7 @@ public class EvmManagerTests
Assert.True(balances.Count > 0);
}
[Ignore]
[Theory]
[InlineData(Ticker.BTC, Timeframe.FiveMinutes)]
public async void Get_Prices(Ticker ticker, Timeframe timeframe)
@@ -186,10 +193,12 @@ public class EvmManagerTests
{
candles = await manager.GetCandles(SubgraphProvider.ChainlinkGmx, ticker, DateTime.UtcNow, timeframe);
}
Assert.NotNull(candles);
Assert.True(candles.Any());
}
[Ignore]
[Fact]
public async void Get_Available_Tickers()
{
@@ -199,6 +208,7 @@ public class EvmManagerTests
Assert.NotEmpty(tickers);
}
[Ignore]
[Fact]
public async void GetLastCandle()
{
@@ -208,6 +218,7 @@ public class EvmManagerTests
Assert.NotNull(candle);
}
[Ignore]
[Fact]
public async void Should_Init_Address_For_Trading()
{
@@ -217,6 +228,7 @@ public class EvmManagerTests
Assert.True(accountInitilized);
}
[Ignore]
[Fact]
public async void Should_send_eth_from_account()
{
@@ -236,6 +248,7 @@ public class EvmManagerTests
Assert.True(sendResult);
}
[Ignore]
[Fact]
public async void Should_send_Gmx_from_account()
{
@@ -248,132 +261,43 @@ public class EvmManagerTests
chain,
Ticker.GMX,
balance.Balance / 2,
PublicAddress,
PublicAddress,
"",
receiverAddress);
Assert.True(sendResult);
}
[Ignore]
[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()
public async void Should_return_allowance()
{
var manager = new EvmManager(Subgraphs);
var account = GetAccount();
var account = PrivateKeys.GetAccount();
var orders = await manager.GetOrders(account, Ticker.BTC);
Assert.IsType<List<Trade>>(orders);
var allowance = await manager.GetAllowance(account.Key, Ticker.BTC);
Assert.IsType<decimal>(allowance);
}
[Ignore]
[Fact]
public async void Should_cancel_gmx_orders()
public async void Should_set_allowance()
{
var manager = new EvmManager(Subgraphs);
var account = GetAccount();
var account = PrivateKeys.GetAccount();
var cancelled = await manager.CancelOrders(account, Ticker.BTC);
// Get amount from balance
var balance = await manager.GetTokenBalance(Constants.Chains.Arbitrum, Ticker.USDC, account.Key);
Assert.IsType<bool>(cancelled);
}
private static Account GetAccount()
{
return new Account
{
Key = "PublicAddress",
Secret = "PrivateKey"
};
var result = await manager.SetAllowance(account, Ticker.USDC, new BigInteger(balance.Balance));
Assert.True(result);
}
[Fact]
public void Should_convert_quantity()
public async void Should_return_GmxGasPrice()
{
var quantity = Web3.Convert.ToWei(0.0019);
Assert.IsType<BigInteger>(quantity);
var result =
await EvmBase.GetGasPrice(new Web3(_chains.First(c => c.Name == Constants.Chains.Arbitrum).RpcUrl));
Assert.True(result > 0);
}
[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);
}
}
}

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

77
src/Managing.Infrastructure.Tests/GmxHelpersTests.cs Normal file
View File

@@ -0,0 +1,77 @@
using System.Numerics;
using Managing.Common;
using Managing.Infrastructure.Evm.Services.Gmx;
using Xunit;
namespace Managing.Infrastructure.Tests;
public class GmxHelpersTests
{
[Fact]
public void Should_return_correct_usd_formatting_for_sizeDelta()
{
// Arrange
var sizeDelta = BigInteger.Parse("19970983955394369245200000000000");
// Act
var result = GmxHelpers.FormatAmount(sizeDelta, 30, 2);
// Assert
Assert.Equal(19.97m, result);
}
[Theory]
[InlineData("2200000000000000", Enums.Ticker.ETH, 2200)]
[InlineData("500000000000000000000000000", Enums.Ticker.BTC, 50000)]
[InlineData("759434500000000000000000000", Enums.Ticker.BTC, 75943.45)]
[InlineData("100000000000000000000000", Enums.Ticker.SOL, 100)]
public void Should_return_correct_usd_formatting_for_triggerPrice(string triggerPriceString, Enums.Ticker ticker,
decimal expected)
{
// Arrange
var triggerPrice = BigInteger.Parse(triggerPriceString);
var indexToken = TokenV2Service.TOKENS.First(t => t.Symbol == ticker.ToString());
// Act
var result = GmxV2Helpers.ParseContractPrice(triggerPrice, indexToken.Decimals, true);
// Assert
Assert.Equal(expected, result);
}
[Theory]
[InlineData(50200, "502000000000000000000000000")]
public void Should_correctly_parse_value_to_contract_price(decimal triggerPrice, string expected)
{
var indexToken = TokenV2Service.TOKENS.First(t => t.Symbol == Enums.Ticker.BTC.ToString());
var triggerPriceValue = GmxV2Helpers.ConvertToContractPrice(triggerPrice, indexToken.Decimals, true);
var expectedPrice = BigInteger.Parse(expected);
Assert.IsType<BigInteger>(triggerPriceValue);
Assert.Equal(expectedPrice, triggerPriceValue);
}
[Theory]
[InlineData("10000000", 10)]
public void Should_return_correct_usd_formatting_for_collateralDeltaAmount(string priceString, decimal expected)
{
// Arrange
var price = BigInteger.Parse(priceString);
var shortToken = TokenV2Service.TOKENS.First(t => t.Symbol == "USDC");
// Act
var result = GmxV2Helpers.ParseContractPrice(price, shortToken.Decimals, false);
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Helpers_Should_Validate_Exact_Same_Address()
{
var address = "0x47904963Fc8b2340414262125aF798B9655E58Cd";
var address2 = "0x47904963fc8b2340414262125aF798B9655E58Cd";
Assert.True(GmxV2Helpers.SameAddress(address, address2));
}
}

130
src/Managing.Infrastructure.Tests/GmxServiceTests.cs Normal file
View File

@@ -0,0 +1,130 @@
using System.Numerics;
using Managing.Common;
using Managing.Domain.Trades;
using Managing.Infrastructure.Evm;
using Managing.Infrastructure.Evm.Models.Gmx.v1;
using Managing.Infrastructure.Evm.Referentials;
using Managing.Infrastructure.Evm.Services;
using Managing.Infrastructure.Evm.Services.Gmx;
using Nethereum.Web3;
using Xunit;
namespace Managing.Infrastructure.Tests;
public class GmxServiceTests : EvmManagerTests
{
[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, Enums.Ticker.BTC);
Assert.IsType<List<GmxOrder>>(orders);
}
[Fact]
public async void Should_return_orders()
{
var manager = new EvmManager(Subgraphs);
var account = PrivateKeys.GetAccount();
var orders = await manager.GetOrders(account, Enums.Ticker.BTC);
Assert.IsType<List<Trade>>(orders);
}
[Fact]
public async void Should_cancel_gmx_orders()
{
var manager = new EvmManager(Subgraphs);
var account = PrivateKeys.GetAccount();
var cancelled = await manager.CancelOrders(account, Enums.Ticker.BTC);
Assert.IsType<bool>(cancelled);
}
[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 account = PrivateKeys.GetAccount();
var web3 = new Web3(chain.RpcUrl);
var approval = await GmxService.ApproveOrder(web3, Enums.Ticker.BTC, account.Key, 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 account = PrivateKeys.GetAccount();
var quantity = await manager.QuantityInPosition(Constants.Chains.Arbitrum, account.Key, Enums.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, "", Enums.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, "", Enums.Ticker.ETH);
Assert.IsType<Trade>(position);
}
}

135
src/Managing.Infrastructure.Tests/GmxServiceV2Tests.cs
View File

@@ -1,7 +1,9 @@
using System.Numerics;
using Managing.Common;
using Managing.Infrastructure.Evm.Models.Gmx.v2;
using Managing.Infrastructure.Evm.Referentials;
using Managing.Infrastructure.Evm.Services;
using Managing.Infrastructure.Evm.Services.Gmx;
using Nethereum.Hex.HexConvertors.Extensions;
using Nethereum.Web3;
using Xunit;
@@ -100,15 +102,6 @@ public class GmxV2ServiceTests
Assert.NotNull(result);
}
[Fact]
public void Helpers_Should_Validate_Exact_Same_Address()
{
var address = "0x47904963Fc8b2340414262125aF798B9655E58Cd";
var address2 = "0x47904963fc8b2340414262125aF798B9655E58Cd";
Assert.True(GmxV2Helpers.SameAddress(address, address2));
}
[Fact]
public void Should_Return_Correct_Long_Key()
{
@@ -118,4 +111,126 @@ public class GmxV2ServiceTests
Assert.NotNull(keys);
Assert.Equal(expectedKey, keys.LongInterestUsingLongToken);
}
[Fact]
public void Should_Hash_Correctly_Simple_Key()
{
var key = "POSITION_IMPACT_FACTOR";
var keys = new GmxV2Encoder().HashString(key);
var expectedKey = "0xdbe66c23ce3688bc34131316a8b4dd967631de35afb1dbb972bc1b7c71c4a18b";
Assert.NotNull(keys);
Assert.Equal(expectedKey.HexToByteArray(), keys);
}
[Fact]
public void Should_Hash_Correctly_Complex_Key()
{
var helper = new GmxV2Encoder();
var openInterestKey = "OPEN_INTEREST";
var hashedOpenInterestKey = helper.HashString(openInterestKey);
var expectedOpenInterestKey = "0x4259c04608de5df0fa0e375507d66e8ffc81773c9f3dd501a181cbb349ae4fe0";
Assert.Equal(expectedOpenInterestKey.HexToByteArray(), hashedOpenInterestKey);
var datas = new List<(string dataType, object dataValues)>();
datas.Add(("bytes32", hashedOpenInterestKey));
datas.Add(("address", Constants.GMX.Markets.BTCUSDC));
datas.Add(("address", Constants.GMX.TokenAddress.WBTC));
datas.Add(("bool", true));
var hashData = helper.HashData(datas);
var expectedFullKey = "0xaaf79028722fd65633cdf994a4a10b0bd349761062506c4bb6a0489956ba5d3f".HexToByteArray();
Assert.NotNull(hashData);
Assert.Equal(expectedFullKey, hashData);
}
[Fact]
public async void Should_return_GmxGasLimit()
{
var result = await _service.GetGasLimit(_web3);
Assert.NotNull(result);
}
[Theory]
[InlineData(50200, "503506000000000000000000000", Enums.Ticker.BTC)]
public void Should_return_correct_acceptable_price(decimal price, string expected, Enums.Ticker ticker)
{
var isLong = true;
var isIncrease = true;
var acceptablePrice = GmxV2Helpers.GetAcceptablePrice(price, isLong);
var expectedPrice = BigInteger.Parse(expected);
Assert.IsType<BigInteger>(acceptablePrice);
Assert.Equal(expectedPrice, acceptablePrice);
}
[Fact]
public async Task Should_return_execution_fee()
{
var executionFee = await _service.GetExecutionFee(_web3, GmxV2Enums.TradeType.Increase);
var expectedExecutionFee = BigInteger.Parse("56084990000000");
// No need to check the execution fee since it's dynamic
// Assert.True(IsCloseTo(expectedExecutionFee, executionFee.FeeAmount, 2000000000000));
Assert.NotNull(executionFee);
}
[Theory]
[InlineData(19, "18986709")]
public async Task Should_return_correct_collateral_amount(decimal price, string expected)
{
var usdcToken = TokenV2Service.TOKENS.First(t => t.Symbol == Enums.Ticker.USDC.ToString());
var initialCollateralAmount = GmxV2Helpers.ParseValue(price, usdcToken.Decimals);
var expectedAmount = BigInteger.Parse(expected);
var executionFee = await _service.GetExecutionFee(_web3, GmxV2Enums.TradeType.Increase);
var amountToIncrease = initialCollateralAmount + executionFee.FeeAmount;
var expectedExecutionFee = BigInteger.Parse("56084990000000");
// No need to check the execution fee since it's dynamic
// Assert.True(IsCloseTo(expectedExecutionFee, executionFee.FeeAmount, 2000000000000));
Assert.IsType<BigInteger>(amountToIncrease);
Assert.True(IsCloseTo(expectedAmount, amountToIncrease, 2000000));
}
private bool IsCloseTo(BigInteger expected, BigInteger actual, BigInteger tolerance)
{
var diff = BigInteger.Abs(expected - actual);
return diff < tolerance;
}
[Fact]
public void Should_return_correct_delta_usd_amount()
{
var expected = "53954097244701048554400000000000";
var input = 54;
var usdcToken = TokenV2Service.TOKENS.First(t => t.Symbol == Enums.Ticker.USDC.ToString());
var deltaUsdAmount = GmxV2Helpers.ParseValue(input, 30);
Assert.True(IsCloseTo(BigInteger.Parse(expected),
deltaUsdAmount,
BigInteger.Parse("1395409724470104855440000000000")));
}
[Fact]
public void Should_return_correct_trigger_price()
{
var expected = "589010000000000000000000000";
var price = 58901;
var token = TokenV2Service.TOKENS.First(t => t.Symbol == Enums.Ticker.BTC.ToString());
var triggerPrice = GmxV2Helpers.ConvertToContractPrice(price, token.Decimals, true);
Assert.Equal(BigInteger.Parse(expected),
triggerPrice);
}
[Fact]
public async void Should_return_oraclePrices()
{
var service = new OracleKeeperService();
var result = await service.GetTickers();
Assert.NotNull(result);
}
}

29
src/Managing.Infrastructure.Tests/GmxTradingTests.cs Normal file
View File

@@ -0,0 +1,29 @@
using Managing.Common;
using Managing.Domain.Trades;
using Managing.Infrastructure.Evm;
using Xunit;
namespace Managing.Infrastructure.Tests;
public class GmxTradingTests : EvmManagerTests
{
[Fact]
public async void Should_return_orders()
{
var manager = new EvmManager(Subgraphs);
var account = PrivateKeys.GetAccount();
var orders = await manager.GetOrders(account, Enums.Ticker.SOL);
Assert.IsType<List<Trade>>(orders);
}
[Fact]
public async void Should_cancel_order()
{
var manager = new EvmManager(Subgraphs);
var account = PrivateKeys.GetAccount();
var result = await manager.CancelOrders(account, Enums.Ticker.BTC);
Assert.True(result);
}
}

19
src/Managing.Infrastructure.Tests/PrivateKeys.cs Normal file
View File

@@ -0,0 +1,19 @@
using Managing.Common;
using Managing.Domain.Accounts;
namespace Managing.Infrastructure.Tests;
public static class PrivateKeys
{
public static Account GetAccount()
{
// TODO Never commit this
return new Account
{
Exchange = Enums.TradingExchanges.GmxV2,
Type = Enums.AccountType.Trader,
Key = "",
Secret = ""
};
}
}