public async Task <string> CancelOrderAsync(Interface.Model.User user, string symbol, long orderId, string newClientOrderId = null, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.CancelOrderAsync(apiUser, symbol, orderId, newClientOrderId, recWindow, cancellationToken).ConfigureAwait(false);
return(result);
}
private Interface.Model.Order NewOrder(Interface.Model.User user, Order o)
{
return(new Interface.Model.Order
{
User = user,
Symbol = o.Symbol,
Id = o.Id,
ClientOrderId = o.ClientOrderId,
Price = o.Price,
OriginalQuantity = o.OriginalQuantity,
ExecutedQuantity = o.ExecutedQuantity,
Status = (Interface.Model.OrderStatus)o.Status,
TimeInForce = (Interface.Model.TimeInForce)o.TimeInForce,
Type = (Interface.Model.OrderType)o.Type,
Side = (Interface.Model.OrderSide)o.Side,
StopPrice = o.StopPrice,
IcebergQuantity = o.IcebergQuantity,
Time = o.Time,
IsWorking = o.IsWorking,
Fills = o.Fills?.Select(f => new Interface.Model.Fill
{
Price = f.Price,
Quantity = f.Quantity,
Commission = f.Commission,
CommissionAsset = f.CommissionAsset,
TradeId = f.TradeId
})
});
}
public async Task <Interface.Model.Order> PlaceOrder(Interface.Model.User user, Interface.Model.ClientOrder clientOrder, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
var order = OrderHelper.GetOrder(user, clientOrder);
var result = await binanceApi.PlaceAsync(order).ConfigureAwait(false);
return(NewOrder(user, result));
}
public async Task SubscribeAccountInfo(Interface.Model.User user, Action <AccountInfoEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var streamControl = new UserDataWebSocketStreamControl(binanceApi);
var listenKey = await streamControl.OpenStreamAsync(apiUser).ConfigureAwait(false);
var accountInfoCache = new AccountInfoCache(binanceApi, new UserDataWebSocketClient());
accountInfoCache.Subscribe(listenKey, apiUser, e =>
{
if (cancellationToken.IsCancellationRequested)
{
accountInfoCache.Unsubscribe();
return;
}
try
{
var accountInfo = GetAccountInfo(e.AccountInfo);
accountInfo.User = user;
callback.Invoke(new AccountInfoEventArgs {
AccountInfo = accountInfo
});
}
catch (Exception ex)
{
accountInfoCache.Unsubscribe();
exception.Invoke(ex);
return;
}
});
}
public async Task <IEnumerable <Interface.Model.Order> > GetOpenOrdersAsync(Interface.Model.User user, string symbol = null, long recWindow = 0, Action <Exception> exception = default(Action <Exception>), CancellationToken cancellationToken = default(CancellationToken))
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.GetOpenOrdersAsync(apiUser, symbol, recWindow, cancellationToken).ConfigureAwait(false);
var orders = result.Select(o => NewOrder(user, o)).ToList();
return(orders);
}
public static ClientOrder GetOrder(Interface.Model.User user, Interface.Model.ClientOrder clientOrder)
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var orderType = (OrderType)clientOrder.Type;
switch (orderType)
{
case OrderType.Market:
return(new MarketOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity
});
case OrderType.StopLoss:
return(new StopLossOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, StopPrice = clientOrder.StopPrice
});
case OrderType.TakeProfit:
return(new TakeProfitOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, StopPrice = clientOrder.StopPrice
});
case OrderType.Limit:
return(new LimitOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, Price = clientOrder.Price
});
case OrderType.LimitMaker:
return(new LimitMakerOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, Price = clientOrder.Price
});
case OrderType.StopLossLimit:
return(new StopLossLimitOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, StopPrice = clientOrder.StopPrice, Price = clientOrder.Price
});
case OrderType.TakeProfitLimit:
return(new TakeProfitLimitOrder(apiUser)
{
Symbol = clientOrder.Symbol, Side = (OrderSide)clientOrder.Side, Quantity = clientOrder.Quantity, StopPrice = clientOrder.StopPrice, Price = clientOrder.Price
});
default:
throw new System.Exception("Unknown order type.");
}
}
public async Task <Interface.Model.AccountInfo> GetAccountInfoAsync(Interface.Model.User user, CancellationToken cancellationToken)
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.GetAccountInfoAsync(apiUser, 0, cancellationToken).ConfigureAwait(false);
var accountInfo = GetAccountInfo(result);
user.RateLimiter = new Interface.Model.RateLimiter {
IsEnabled = result.User.RateLimiter.IsEnabled
};
accountInfo.User = user;
return(accountInfo);
}
public static void ClientOrderValidationBuilderTest_Initialize(TestContext testContext)
{
apiKey = "abcdefghijklmnopqrstuvwxyz";
user = new Interface.Model.User()
{
ApiKey = apiKey
};
var balance = new Interface.Model.AccountBalance {
Asset = "TRX", Free = 300, Locked = 100
};
balances = new List <Interface.Model.AccountBalance>()
{
balance
};
}
public Task <IEnumerable <Interface.Model.AccountTrade> > GetAccountTradesAsync(Exchange exchange, Interface.Model.User user, string symbol, DateTime startDate, DateTime endDate, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
return(exchangeService.GetAccountTradesAsync(exchange, user, symbol, startDate, endDate, recWindow, cancellationToken));
}
public Task <string> CancelOrderAsync(Exchange exchange, Interface.Model.User user, string symbol, string orderId, string newClientOrderId = null, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
return(exchangeService.CancelOrderAsync(exchange, user, symbol, orderId, newClientOrderId, recWindow, cancellationToken));
}
public Task <Interface.Model.Order> PlaceOrder(Exchange exchange, Interface.Model.User user, Interface.Model.ClientOrder clientOrder, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
return(exchangeService.PlaceOrder(exchange, user, clientOrder, recWindow, cancellationToken));
}
public async Task <Account> GetAccountInfoAsync(Exchange exchange, Interface.Model.User user, CancellationToken cancellationToken)
{
var accountInfo = await exchangeService.GetAccountInfoAsync(exchange, user, cancellationToken).ConfigureAwait(false);
return(new Account(accountInfo));
}
public async Task <IEnumerable <Order> > GetOpenOrdersAsync(Exchange exchange, Interface.Model.User user, string symbol = null, long recWindow = 0, Action <Exception> exception = default(Action <Exception>), CancellationToken cancellationToken = default(CancellationToken))
{
var result = await exchangeService.GetOpenOrdersAsync(exchange, user, symbol, recWindow, exception, cancellationToken).ConfigureAwait(false);
var orders = result.Select(o => o.GetViewOrder()).ToList();
return(orders);
}
public Task SubscribeAccountInfo(Exchange exchange, Interface.Model.User user, Action <AccountInfoEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
return(exchangeService.SubscribeAccountInfo(exchange, user, callback, exception, cancellationToken));
}
public async Task <IEnumerable <Interface.Model.AccountTrade> > GetAccountTradesAsync(Interface.Model.User user, string symbol, DateTime startDate, DateTime endDate, long recWindow = 0, CancellationToken cancellationToken = default(CancellationToken))
{
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.GetAccountTradesAsync(apiUser, symbol, startDate, endDate, recWindow, cancellationToken).ConfigureAwait(false);
var accountTrades = result.Select(at => NewAccountTrade(at)).ToList();
return(accountTrades);
}
public void SubscribeAccountInfo(Interface.Model.User user, Action <AccountInfoEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
SubscribeAccountInfoAsync(user, callback, exception, cancellationToken).FireAndForget();
}
