/// <summary>
/// Check for the book trades.
/// </summary>
/// <param name="book"></param>
/// <param name="marker"></param>
/// <param name="sort"></param>
/// <param name="limit"></param>
/// <returns></returns>
public async Task <ICollection <Trades> > BookTradesAsync(string book, int marker = 0, int limit = 0, string sort = null)
{
string uri = "trades/?book=" + book;
if (marker > 0)
{
uri += "&marker=" + marker;
}
if (!string.IsNullOrEmpty(sort))
{
uri += "&sort=asc";
}
if (limit > 0 && limit <= 100)
{
uri += "&limit=" + limit;
}
TradesResponse traderesponse = null;
HttpResponseMessage response = await JSONcallerAsync(uri);
if (response.IsSuccessStatusCode)
{
var result = response.Content.ReadAsStringAsync().Result;
traderesponse = JsonConvert.DeserializeObject <TradesResponse>(result);
}
return(traderesponse.payload);
}
/// <summary>
/// Retrieves the list of open trades belonging to the account
/// </summary>
/// <param name="account">the account to retrieve the list for</param>
/// <param name="requestParams">optional additional parameters for the request (name, value pairs)</param>
/// <returns>List of TradeData objects (or empty list, if no trades)</returns>
public static async Task <List <TradeData> > GetTradeListAsync(int account, Dictionary <string, string> requestParams = null)
{
string requestString = Server(EServer.Account) + "accounts/" + account + "/trades";
TradesResponse tradeResponse = await MakeRequestAsync <TradesResponse>(requestString, "GET", requestParams);
var trades = new List <TradeData>();
trades.AddRange(tradeResponse.trades);
return(trades);
}
public override async Task <TradesResponse> GetOrderTrades(OrderTradesRequest request, ServerCallContext context)
{
var trades = await _historyClient.GetOrderTradesAsync(context.GetHttpContext().User.GetWalletId(), request.OrderId);
var res = new TradesResponse();
var data = _mapper.Map <List <Trade> >(trades);
res.Payload.AddRange(data);
return(res);
}
/// <summary>
/// Retrieves the list of all open trades belonging to the account
/// </summary>
/// <param name="account">the account to retrieve the list for</param>
/// <returns>List of TradeData objects (or empty list, if no trades)</returns>
public static async Task <List <Trade> > GetOpenTradeListAsync(string account)
{
string requestString = Server(EServer.Account) + "accounts/" + account + "/openTrades";
TradesResponse tradeResponse = await MakeRequestAsync <TradesResponse>(requestString);
var trades = new List <Trade>();
trades.AddRange(tradeResponse.trades);
return(trades);
}
/// <summary>
/// Gets the list of accounts for a specific user
/// </summary>
/// <param name="user">the username of the user</param>
/// <returns>list of accounts</returns>
/// <summary>
/// Gets the list of open trades for a given account
/// </summary>
/// <param name="account">the account ID of the account</param>
/// <returns>list of open trades (empty list if there are none)</returns>
public static List <TradeData> GetTradeList(int account)
{
string requestString = sApiServer + "v1/accounts/" + account + "/trades";
string responseString = MakeRequest(requestString);
JavaScriptSerializer serializer = new JavaScriptSerializer();
TradesResponse tradeResponse = serializer.Deserialize <TradesResponse>(responseString);
List <TradeData> trades = new List <TradeData>();
trades.AddRange(tradeResponse.Trades);
// TODO: should loop through the "next pages"
return(trades);
}
public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
{
var result = await _validationService.ValidateTradesRequestAsync(request.AssetPairId, request.Offset, request.Take);
if (result != null)
{
return(new TradesResponse
{
Error = new Error
{
Code = _mapper.Map <ErrorCode>(result.Code),
Message = result.Message
}
});
}
DateTime?from = null;
DateTime?to = null;
if (request.OptionalFromCase != TradesRequest.OptionalFromOneofCase.None)
{
from = request.From.ToDateTime();
}
if (request.OptionalToCase != TradesRequest.OptionalToOneofCase.None)
{
to = request.To.ToDateTime();
}
var orderAction = request.OptionalSideCase == TradesRequest.OptionalSideOneofCase.None
? (OrderAction?)null
: _mapper.Map <OrderAction>(request.Side);
if (request.Take == 0)
{
request.Take = Constants.MaxPageSize;
}
var trades = await _historyClient.GetTradersAsync(context.GetHttpContext().User.GetWalletId(),
request.AssetPairId, request.Offset, request.Take, orderAction, from, to);
var res = new TradesResponse();
var data = _mapper.Map <List <Trade> >(trades);
res.Payload.AddRange(data);
return(res);
}
public static void TradesEvent(object sender, TradesResponse response)
{
if (response.Event == EventType.Subscribed)
{
Console.WriteLine("*You succesfully subscribed to Trade updates. For pair '" + response.Symbol + "'\n");
}
else if (response.Event == EventType.Updated)
{
Console.WriteLine("*** New trade occurred for pair: '" + response.Symbol + "'");
Console.WriteLine("Timestamp " + response.Timestamp);
Console.WriteLine("Side: " + response.Side);
Console.WriteLine("Qty: " + response.Qty);
Console.WriteLine("Price: " + response.Price);
Console.WriteLine("trade_id: " + response.Trade_id);
Console.WriteLine("\n\n");
}
}
public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
{
var session = SessionFromContext(context);
var assetPairId = request.OptionalAssetPairIdCase == TradesRequest.OptionalAssetPairIdOneofCase.AssetPairId
? request.AssetPairId
: string.Empty;
DateTime?fromTime = request.OptionalFromDateCase == TradesRequest.OptionalFromDateOneofCase.From
? request.From.ToDateTime()
: (DateTime?)null;
DateTime?toTime = request.OptionalToDateCase == TradesRequest.OptionalToDateOneofCase.To
? request.To.ToDateTime()
: (DateTime?)null;
var side = request.OptionalTradeTypeCase == TradesRequest.OptionalTradeTypeOneofCase.TradeType
? request.TradeType
: string.Empty;
var trades = await _clientWalletService.GetClientTradesAsync(session.TenantId, session.ClientId,
assetPairId, fromTime, toTime, side, request.Skip, request.Take);
var resp = new TradesResponse();
foreach (var trade in trades)
{
resp.Trades.Add(new TradesResponse.Types.TradeModel()
{
Id = trade.TradeId,
AssetPairId = trade.BaseAssetId + trade.QuotingAssetId, //todo: take Id from AssetPair list
Timestamp = Timestamp.FromDateTime(DateTime.SpecifyKind(trade.Timestamp, DateTimeKind.Utc)),
Price = trade.Price,
BaseVolume = trade.BaseVolume.Replace("-", ""),
BaseAssetName = trade.BaseAssetId,
QuoteVolume = trade.QuotingVolume,
QuoteAssetName = trade.QuotingAssetId,
Direction = trade.BaseVolume.StartsWith("-") ? "Sell" : "Buy",
OrderId = trade.ExternalOrderId
});
}
return(resp);
}
public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
{
var result = await _validationService.ValidateTradesRequestAsync(request.AssetPairId, request.Offset, request.Take);
if (result != null)
{
return(new TradesResponse
{
Error = new Error
{
Code = (int)result.Code,
Message = result.Message
}
});
}
DateTime?from = null;
DateTime?to = null;
if (DateTime.TryParse(request.From, out var fromDate))
{
from = fromDate;
}
if (DateTime.TryParse(request.To, out var toDate))
{
to = toDate;
}
var orderAction = request.OptionalSideCase == TradesRequest.OptionalSideOneofCase.None
? (OrderAction?)null
: request.Side == Side.Buy ? OrderAction.Buy : OrderAction.Sell;
var trades = await _historyClient.GetTradersAsync(context.GetHttpContext().User.GetWalletId(),
request.AssetPairId, request.Offset, request.Take, orderAction, from, to);
var res = new TradesResponse();
var data = _mapper.Map <List <Trade> >(trades);
res.Payload.AddRange(data);
return(res);
}
private void OnTradesResponse(TradesResponse response)
{
foreach (var trade in response.Trades)
{
SendOutMessage(new ExecutionMessage
{
SecurityId = new SecurityId {
Native = trade.SecId
},
OrderId = trade.OrderNo,
TradeId = trade.TradeNo,
TradePrice = trade.Price,
Side = trade.BuySell.FromTransaq(),
ServerTime = trade.Time,
Comment = trade.BrokerRef,
Volume = trade.Quantity,
PortfolioName = trade.Client,
ExecutionType = ExecutionTypes.Trade,
Commission = trade.Commission,
});
}
}
public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context)
{
var result = new TradesResponse();
var token = context.GetBearerToken();
var wallets = await _clientAccountClient.Wallets.GetClientWalletsFilteredAsync(context.GetClientId(), WalletType.Trading);
var walletId = wallets.FirstOrDefault()?.Id;
var response = await _walletApiV2Client.GetTradesByWalletIdAsync(
walletId, request.AssetPairId, request.Take, request.Skip,
request.OptionalFromDateCase == TradesRequest.OptionalFromDateOneofCase.None?(DateTimeOffset?)null : request.From.ToDateTimeOffset(),
request.OptionalToDateCase == TradesRequest.OptionalToDateOneofCase.None?(DateTimeOffset?)null : request.To.ToDateTimeOffset(),
request.OptionalTradeTypeCase == TradesRequest.OptionalTradeTypeOneofCase.None?null : (TradeType?)Enum.Parse(typeof(TradeType?), request.TradeType),
token);
if (response != null)
{
result.Body = new TradesResponse.Types.Body();
result.Body.Trades.AddRange(_mapper.Map <List <TradesResponse.Types.TradeModel> >(response));
}
return(result);
}
private void ListaTransakcji()
{
try
{
SyncAPIConnector connector = new SyncAPIConnector(serverData);
Credentials credentials = new Credentials(userId, password, "", "pixelNet");
LoginResponse loginResponse = APICommandFactory.ExecuteLoginCommand(connector, credentials, true);
TradesResponse tradesResponse = APICommandFactory.ExecuteTradesCommand(connector, true);
listaTran.Items.Clear();
foreach (xAPI.Records.TradeRecord rec in tradesResponse.TradeRecords)
{
string rodz = "";
if (rec.Cmd == 1)
{
rodz = "Sell";
}
else
{
rodz = "Buy";
}
listaTran.Items.Add(new PozTran()
{
Nazwa = rec.Symbol,
CenaZak = (double)rec.Open_price,
Zysk = (double)rec.Profit,
Rodzaj = rodz
});;
//if (rec.Profit > 30) TransakcjaStop(rec);
LogoutResponse logoutResponse = APICommandFactory.ExecuteLogoutCommand(connector);
}
tradesResponse = null;
} catch { }
}
static void Main(string[] args)
{
TradeioApi api = new TradeioApi("aaaaaaaa-bbbb-cccc-dddd-eeeeeeee", "aaaaaaaa-bbbb-cccc-dddd-eeeeeeee");
string symbol = "btc_usdt";
Console.WriteLine("******PAIRS******");
PairsResponse pairsResponse = api.GetPairs().Result;
Console.WriteLine(string.Join(',', pairsResponse.Pairs));
Console.WriteLine("******CANDLES******");
CandlesResponse candles = api.GetCandles("btc_usdt", CandleInterval.OneDay, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow, 20).Result;
foreach (CandleInfo candle in candles.Candles)
{
Console.WriteLine($"open: {candle.Open}; close: {candle.Close}; low: {candle.Low}; high: {candle.High}");
}
Console.WriteLine("******ORDER BOOK******");
OrderBookResponse orderBookResponse = api.GetOrderBook(symbol, 2).Result;
Console.WriteLine("***ASK***");
foreach (var askArray in orderBookResponse.Book.Asks)
{
Console.WriteLine($"Price: {askArray[0]}; Count: {askArray[1]}");
}
Console.WriteLine("***BID***");
foreach (var bidArray in orderBookResponse.Book.Bids)
{
Console.WriteLine($"Price: {bidArray[0]}; Count: {bidArray[1]}");
}
Console.WriteLine("******TICKER******");
TickerResponse tickerResponse = api.GetTicker(symbol).Result;
Console.WriteLine($"ASK price: {tickerResponse.Ticker.AskPrice}, qty: {tickerResponse.Ticker.AskQty}; BID price: {tickerResponse.Ticker.BidPrice}, qty: {tickerResponse.Ticker.BidQty}");
//tickers for all pairs
//var tickers = api.GetTickers().Result;
Console.WriteLine("******RECENT TRADES******");
TradesResponse tradesResponse = api.GetRecentTrades("btc_usdt", 2).Result;
foreach (TradeInfo trade in tradesResponse.Trades)
{
Console.WriteLine($"{trade.Symbol} price: {trade.Price}, qty: {trade.Quantity}, side: {trade.Type}, date: {UnixTime.GetDateTime(trade.Time)} UTC");
}
//PRIVATE METHODS. NOT WORKING WITHOUT PUBLIC AND PRIVATE KEY
Console.WriteLine("******CURRENT BALANCES******");
AccountBalanceResponse accountBalance = api.GetAccount().Result;
foreach (BalanceInfo balanceInfo in accountBalance.Balances)
{
Console.WriteLine($"{balanceInfo.Asset}:{balanceInfo.Available} (locked: {balanceInfo.Locked})");
}
Console.WriteLine("******OPEN ORDERS******");
OrdersResponse ordersResponse = api.GetOpenOrders(symbol).Result;
foreach (OrderInfoResponse order in ordersResponse.Orders)
{
Console.WriteLine($"{order.Side} {order.Instrument} for {order.Price}. Filled: {order.UnitsFilled}");
}
Console.WriteLine("******CLOSED ORDERS******");
FilteredResponse <OrderInfoResponse> closeOrdersResponse = api.GetClosedOrders(symbol, UnixTime.Get(DateTime.UtcNow.AddDays(-1)), UnixTime.Get(DateTime.UtcNow)).Result;
foreach (OrderInfoResponse order in closeOrdersResponse.Data)
{
Console.WriteLine($"{order.Side} {order.Instrument} for {order.Price}. Filled: {order.UnitsFilled}. Status: {order.Status}");
}
Console.WriteLine("******PLACE ORDER******");
var orderResponse = api.PlaceOrder(new Models.OrderRequest()
{
Price = 4000,
Quantity = 10,
Side = Models.OrderSide.Buy,
Symbol = symbol,
Type = Models.OrderType.Limit
}).Result;
Console.WriteLine("******CANCEL ORDER******");
Response response = api.CancelOrder(orderResponse.Order.OrderId).Result;
if (response.Code == 200)
{
Console.WriteLine("Order canceled");
}
Console.ReadLine();
}
// Trades Websocket
private void TradeMessageHandler(TradesResponse messageData)
{
var data = messageData;
}
