public async Task <MyTradesResponse> GetMyTrades(string coin, string market)
{
var e = LogExecutionTime.Begin();
var req = CreateRequest(HttpMethod.Get, BinanceEndpoints.MyTrades, $"symbol={coin}{market}&limit=25");
var res = await GetResponse <List <BinanceMyTrade> >(req, BinanceEndpoints.MyTrades);
if (res == null || res.Count == 0)
{
Logger.LogProxy($"Binance {coin} trades returned empty! Url: {req.RequestUri.AbsoluteUri}", res);
return(new MyTradesResponse
{
IsSuccess = false,
ErrorMessage = $"Binance {coin} trades returned empty! Url: {req.RequestUri.AbsoluteUri}"
});
}
e.End(customMessage: $"{coin}-{market} at Binance ");
return(new MyTradesResponse
{
IsSuccess = true,
Trades = ProxyMapper.MapCoinTrade(res, coin)
});
}
private void CoreLoop()
{
while (loopThreadAlive)
{
try
{
var e = LogExecutionTime.Begin();
var ops = apiManager.GetTickers().ContinueWith(task =>
EventManager.Instance.Fire(new UpdateSummaryEvent()));
Task.WaitAll(new[] { ops }, 60000);
var remaining = LoopThreadInterval - e.EndSilent();
if (remaining > 0)
{
Thread.Sleep((int)remaining);
}
}
catch (Exception e)
{
Logger.LogError($"CoreLoop Error", e);
}
}
}
public void Intercept(IInvocation invocation)
{
if (!(invocation.Method.GetCustomAttributes(typeof(ExecutionTimeLogAttribute), false).FirstOrDefault()
is ExecutionTimeLogAttribute perfAttribute))
{
invocation.Proceed();
return;
}
var e = LogExecutionTime.Begin();
invocation.Proceed();
e.End(invocation.Method.DeclaringType.Name, invocation.Method.Name, perfAttribute.Threshold);
}
public async Task <CoinsTickerResponse> GetTickers()
{
var e = LogExecutionTime.Begin();
var req = CreateRequest(HttpMethod.Get, BinanceEndpoints.TickerAndStats);
var res = await GetResponse <List <BinanceTicker> >(req, BinanceEndpoints.MyTrades);
if (res == null || res.Count == 0)
{
Logger.LogProxy($"Binance tickers returned empty! Url: {req.RequestUri.AbsoluteUri}", res);
return(new CoinsTickerResponse
{
IsSuccess = false,
ErrorMessage = $"Binance tickers returned empty! Url: {req.RequestUri.AbsoluteUri}"
});
}
var temp = new List <ProxyCoinTickerData>();
foreach (var c in res)
{
c.Coin = ParseBinanceSymbol(c.Symbol, out c.Market);
var coinTicker = ProxyMapper.MapBinanceTicker(c);
if (coinTicker.Coin != null)
{
temp.Add(coinTicker);
}
}
e.End();
return(new CoinsTickerResponse
{
IsSuccess = true,
Tickers = temp
});
}
public async Task <PositionsResponse> FetchPositions(bool onlyDefaultMarket)
{
var e = LogExecutionTime.Begin();
var req = CreateRequest(HttpMethod.Get, BinanceEndpoints.Account);
var res = await GetResponse <BinanceResponses.GetBalances>(req, BinanceEndpoints.Account);
if (!IsResultSuccess <PositionsResponse>(res, out var response) || res?.Result == null || res.Result.Count == 0)
{
Logger.LogProxy($"Binance GetBalances Error. Code: {response.ErrorCode} Message: {response.ErrorMessage}");
var positionsResponse = await GetCachedResponse <PositionsResponse>(BinanceEndpoints.Account);
return(positionsResponse.IsCached ? positionsResponse : response);
}
var orders = new Dictionary <string, List <ProxyCoinOrderData> >();
var temp = new List <ProxyPositionData>();
e.LogInterval("GetBalances");
foreach (var balance in res.Result)
{
if (balance.Quantity == 0)
{
continue;
}
if (markets.ContainsKey(balance.Symbol))
{
orders.Add(balance.Symbol, new List <ProxyCoinOrderData>());
foreach (var market in markets[balance.Symbol])
{
if (onlyDefaultMarket && market != defaultMarket)
{
continue;
}
var result = await GetMyTrades(balance.Symbol, market);
if (!result.IsSuccess)
{
continue;
}
orders[balance.Symbol].AddRange(result.Trades);
}
balance.Balance = balance.Quantity;
ParseCoinPosition(balance, orders[balance.Symbol]);
}
temp.Add(new ProxyPositionData
{
Coin = balance.Symbol,
Exchange = Constant.Binance,
Quantity = balance.Quantity,
Available = balance.Available,
Pending = balance.Pending,
BuyPrice = balance.AvgBuyPrice
});
}
e.End();
response.Positions = temp;
response.Trades = orders;
return(response);
}
