private void StartWebsockets()
{
var successSymbols = m_socketClient.SubscribeToAllSymbolTicker((data) =>
{
//Console.WriteLine(">>>>> {0} BINANCE tickers", data.Length);
for (int i = 0; i < data.Length; ++i)
{
m_tick[data[i].Symbol] = data[i];
}
});
var lk = m_client.StartUserStream();
if (lk.Success)
{
m_listenKey = lk.Data.ListenKey;
var successsUser = m_socketClient.SubscribeToUserStream(m_listenKey,
UpdateAccount,
UpdateOrder
);
}
else
{
Console.WriteLine("Error {0} getting BINANCE ListenKey from StartUserStream(): {1}", lk.Error.Code, lk.Error.Message);
}
}
private void SubscribeUserStream()
{
if (ApiKey == null || ApiSecret == null)
{
return;
}
Task.Run(() =>
{
using (var client = new BinanceClient())
{
var startOkay = client.StartUserStream();
if (!startOkay.Success)
{
messageBoxService.ShowMessage($"Error requesting data: {startOkay.Error.Message}", "error", MessageBoxButton.OK, MessageBoxImage.Error);
}
socketClient.SubscribeToUserStream(startOkay.Data.ListenKey, OnAccountUpdate, OnOrderUpdate);
var accountResult = client.GetAccountInfo();
if (accountResult.Success)
{
Assets = new ObservableCollection <AssetViewModel>(accountResult.Data.Balances.Where(b => b.Free != 0 || b.Locked != 0).Select(b => new AssetViewModel()
{
Asset = b.Asset, Free = b.Free, Locked = b.Locked
}).ToList());
}
else
{
messageBoxService.ShowMessage($"Error requesting data: {accountResult.Error.Message}", "error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
});
}
public void SubscribingToUserStream_Should_TriggerWhenOrderUpdateStreamMessageIsReceived()
{
// arrange
var socket = new Mock <IWebsocket>();
socket.Setup(s => s.Close());
socket.Setup(s => s.Connect()).Returns(Task.FromResult(true));
socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>()));
var factory = new Mock <IWebsocketFactory>();
factory.Setup(s => s.CreateWebsocket(It.IsAny <Log>(), It.IsAny <string>())).Returns(socket.Object);
BinanceStreamOrderUpdate result = null;
var client = new BinanceSocketClient {
SocketFactory = factory.Object
};
client.SubscribeToUserStream("test", null, (test) => result = test);
var data = new BinanceStreamOrderUpdate()
{
Event = "executionReport",
EventTime = new DateTime(2017, 1, 1),
AccumulatedQuantityOfFilledTrades = 1.1m,
BuyerIsMaker = true,
Commission = 2.2m,
CommissionAsset = "test",
ExecutionType = ExecutionType.Trade,
I = 100000000000,
OrderId = 100000000000,
Price = 6.6m,
PriceLastFilledTrade = 7.7m,
Quantity = 8.8m,
QuantityOfLastFilledTrade = 9.9m,
RejectReason = OrderRejectReason.AccountCannotSettle,
Side = OrderSide.Buy,
Status = OrderStatus.Filled,
Symbol = "test",
Time = new DateTime(2017, 1, 1),
TimeInForce = TimeInForce.GoodTillCancel,
TradeId = 10000000000000,
Type = OrderType.Limit,
ClientOrderId = "123",
IcebergQuantity = 9.9m,
IsWorking = true,
OriginalClientOrderId = "456",
StopPrice = 10.10m
};
// act
socket.Raise(r => r.OnMessage += null, JsonConvert.SerializeObject(data));
// assert
Assert.IsNotNull(result);
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data, result, "Balances"));
}
public void SubscribingToUserStream_Should_TriggerWhenAccountUpdateStreamMessageIsReceived()
{
// arrange
var socket = new Mock <IWebsocket>();
socket.Setup(s => s.Close());
socket.Setup(s => s.Connect()).Returns(Task.FromResult(true));
socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>()));
var factory = new Mock <IWebsocketFactory>();
factory.Setup(s => s.CreateWebsocket(It.IsAny <Log>(), It.IsAny <string>())).Returns(socket.Object);
BinanceStreamAccountInfo result = null;
var client = new BinanceSocketClient {
SocketFactory = factory.Object
};
client.SubscribeToUserStream("test", (test) => result = test, null);
var data = new BinanceStreamAccountInfo()
{
Event = "outboundAccountInfo",
EventTime = new DateTime(2017, 1, 1),
BuyerCommission = 1.1m,
CanDeposit = true,
CanTrade = true,
CanWithdraw = false,
MakerCommission = 2.2m,
SellerCommission = 3.3m,
TakerCommission = 4.4m,
Balances = new List <BinanceStreamBalance>()
{
new BinanceStreamBalance()
{
Asset = "test1", Free = 1.1m, Locked = 2.2m
},
new BinanceStreamBalance()
{
Asset = "test2", Free = 3.3m, Locked = 4.4m
},
}
};
// act
socket.Raise(r => r.OnMessage += null, JsonConvert.SerializeObject(data));
// assert
Assert.IsNotNull(result);
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data, result, "Balances"));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data.Balances[0], result.Balances[0]));
Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data.Balances[1], result.Balances[1]));
}
public void SubscribeToUserStream(BinanceClient client, BinanceSocketClient socketClient)
{
try {
var userStreamKey = client.StartUserStream();
if (userStreamKey.Error != null)
{
_logger.LogError(userStreamKey.Error.Message);
}
else
{
var userStream = socketClient.SubscribeToUserStream(userStreamKey.Data.ListenKey, OnAccountUpdate, OnOrderUpdate);
if (userStream.Error != null)
{
_logger.LogError(userStream.Error.Message);
}
else
{
binanceHelper.AddToSubscriptionList("UserStream", userStream.Data);
}
}
} catch (Exception ex) {
_logger.LogException(ex);
}
}
static void Main(string[] args)
{
BinanceClient.SetDefaultOptions(new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials("APIKEY", "APISECRET"),
LogVerbosity = LogVerbosity.Debug,
LogWriters = new List <TextWriter> {
Console.Out
}
});
BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions()
{
ApiCredentials = new ApiCredentials("APIKEY", "APISECRET"),
LogVerbosity = LogVerbosity.Debug,
LogWriters = new List <TextWriter> {
Console.Out
}
});
using (var client = new BinanceClient())
{
// Public
var ping = client.Ping();
var exchangeInfo = client.GetExchangeInfo();
var serverTime = client.GetServerTime();
var orderBook = client.GetOrderBook("BNBBTC", 10);
var aggTrades = client.GetAggregatedTrades("BNBBTC", startTime: DateTime.UtcNow.AddMinutes(-2), endTime: DateTime.UtcNow, limit: 10);
var klines = client.GetKlines("BNBBTC", KlineInterval.OneHour, startTime: DateTime.UtcNow.AddHours(-10), endTime: DateTime.UtcNow, limit: 10);
var price = client.GetPrice("BNBBTC");
var prices24h = client.Get24HPrice("BNBBTC");
var allPrices = client.GetAllPrices();
var allBookPrices = client.GetAllBookPrices();
var historicalTrades = client.GetHistoricalTrades("BNBBTC");
// Private
var openOrders = client.GetOpenOrders("BNBBTC");
var allOrders = client.GetAllOrders("BNBBTC");
var testOrderResult = client.PlaceTestOrder("BNBBTC", OrderSide.Buy, OrderType.Limit, 1, price: 1, timeInForce: TimeInForce.GoodTillCancel);
var queryOrder = client.QueryOrder("BNBBTC", allOrders.Data[0].OrderId);
var orderResult = client.PlaceOrder("BNBBTC", OrderSide.Sell, OrderType.Limit, 10, price: 0.0002m, timeInForce: TimeInForce.GoodTillCancel);
var cancelResult = client.CancelOrder("BNBBTC", orderResult.Data.OrderId);
var accountInfo = client.GetAccountInfo();
var myTrades = client.GetMyTrades("BNBBTC");
// Withdrawal/deposit
var withdrawalHistory = client.GetWithdrawHistory();
var depositHistory = client.GetDepositHistory();
var withdraw = client.Withdraw("ASSET", "ADDRESS", 0);
}
var socketClient = new BinanceSocketClient();
// Streams
var successDepth = socketClient.SubscribeToDepthStream("bnbbtc", (data) =>
{
// handle data
});
var successTrades = socketClient.SubscribeToTradesStream("bnbbtc", (data) =>
{
// handle data
});
var successKline = socketClient.SubscribeToKlineStream("bnbbtc", KlineInterval.OneMinute, (data) =>
{
// handle data
});
var successTicker = socketClient.SubscribeToAllSymbolTicker((data) =>
{
// handle data
});
var successSingleTicker = socketClient.SubscribeToSymbolTicker("bnbbtc", (data) =>
{
// handle data
});
string listenKey;
using (var client = new BinanceClient())
listenKey = client.StartUserStream().Data.ListenKey;
var successAccount = socketClient.SubscribeToUserStream(listenKey, data =>
{
// Hanlde account info data
},
data =>
{
// Hanlde order update info data
});
socketClient.UnsubscribeAllStreams();
Console.ReadLine();
}
