internal BinanceSocketClientFutures(Log log, BinanceSocketClient baseClient, BinanceSocketClientOptions options)
{
Log = log;
BaseClient = baseClient;
}
public Class1()
{
BinanceClient.SetDefaultOptions(new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials("APIKEY", "ZkCeNPdKLjXFn9oQehoQwe226E6Z0iW5IOYcnHzMroE969XVuipu543A84uVkzE1"),
LogVerbosity = LogVerbosity.Debug,
// LogWriter = Console.Out
});
BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions()
{
ApiCredentials = new ApiCredentials("APIKEY", "kTGx5jlVkCOvqVa95G1WQ3xa6B1aC5beJiBlQvbzKURvFPcQ4tudS0Hp8JSL3Kkv"),
LogVerbosity = LogVerbosity.Debug,
// LogWriter = Console.Out
});
String symbol = "POABTC";
DateTime?fecha = null;
using (var client = new BinanceClient())
{
/*
* while (true)
* {
* fecha = new DateTime(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day, DateTime.UtcNow.Hour, DateTime.UtcNow.Minute, 0);
* CallResult<BinanceKline[]> klines = client.GetKlines(symbol, KlineInterval.OneMinute, startTime: fecha.Value.AddMinutes(-1), endTime: fecha, limit: 1);
* if (klines.Success) {
* foreach (BinanceKline kline in klines.Data) {
* printKline(kline, symbol);
* }
* }
* Thread.Sleep(60000);
* }
*/
// 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);
*/
DateTime inicio = new DateTime(2018, 4, 7, 14, 30, 0);
DateTime fin = new DateTime(2018, 4, 7, 16, 15, 0);
var klines = client.GetKlines(symbol, KlineInterval.FiveMinutes, startTime: inicio, endTime: fin);
if (klines.Success)
{
foreach (BinanceKline kline in klines.Data)
{
printKline(kline, symbol);
}
}
/*
* 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. SubscribeToKlineStreamAsync("bnbbtc", KlineInterval.OneMinute, (data) =>
* {
* Console.Out.Write("PAR: " + data.Data.Symbol + Environment.NewLine);
* Console.Out.Write("OPEN TIME: " + data.Data.OpenTime + Environment.NewLine);
* Console.Out.Write("CLOSE TIME: " + data.Data.CloseTime + Environment.NewLine);
* Console.Out.Write("OPEN: " + data.Data.Open + Environment.NewLine);
* Console.Out.Write("CLOSE: " + data.Data.Close + Environment.NewLine);
* Console.Out.Write("HIGH: " + data.Data.High + Environment.NewLine);
* Console.Out.Write("LOW: " + data.Data.Low + Environment.NewLine);
* Console.Out.Write("TRADES: " + data.Data.TradeCount + Environment.NewLine);
* Console.Out.Write("VOLUME: " + data.Data.Volume + Environment.NewLine);
* Console.Out.Write("=============== " + data.Data.Volume + Environment.NewLine);
* });
*
* 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();
}
protected override async Task DoWork(PairConfig config, CancellationToken stoppingToken)
{
ExchangeConfig exchangeConfig = await _exchangeConfigProcessor.GetExchangeConfig(Exchange.Code);
while (!stoppingToken.IsCancellationRequested)
{
try
{
string listenKey = String.Empty;
using (BinanceClient client = new BinanceClient())
{
listenKey = client.StartUserStream().Data;
}
using (BinanceSocketClient socketClient = new BinanceSocketClient())
{
ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString);
using (NatsClient natsClient = new NatsClient(cnInfo))
{
if (!natsClient.IsConnected)
{
natsClient.Connect();
}
CallResult <UpdateSubscription> successAccount = socketClient.SubscribeToUserDataUpdates(listenKey,
accountData =>
{
},
async orderData =>
{
Order order = orderData.ToOrder();
Deal deal = await _dealProcessor.UpdateForOrder(order, config);
await natsClient.PubAsJsonAsync(_settings.Value.OrdersQueueName, new Notification <Deal>()
{
Code = ActionCode.UPDATED.Code, Payload = deal
});
},
ocoOrderData =>
{
},
async balancesData =>
{
IEnumerable <Balance> balances = balancesData.Select(x => x.ToBalance());
foreach (Balance balance in balances)
{
await _balanceProcessor.UpdateOrCreate(balance);
}
},
onAccountBalanceUpdate =>
{
});
while (!stoppingToken.IsCancellationRequested)
{
}
natsClient.Disconnect();
await socketClient.UnsubscribeAll();
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
}
}
internal BinanceSocketClientSpot(Log log, BinanceSocketClient baseClient, BinanceSocketClientOptions options)
{
_log = log;
_baseClient = baseClient;
_baseAddress = options.BaseAddress;
}
static void Main(string[] args)
{
var apikey = ConfigurationManager.AppSettings.Get("apiKey");
var secret = ConfigurationManager.AppSettings.Get("apiKey");
BinanceClient.SetDefaultOptions(new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials(apikey, secret),
LogVerbosity = LogVerbosity.Debug,
LogWriters = new List <TextWriter> {
Console.Out
}
});
BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions()
{
ApiCredentials = new ApiCredentials(apikey, secret),
LogVerbosity = LogVerbosity.Debug,
LogWriters = new List <TextWriter> {
Console.Out
}
});
using (var client = new BinanceClient())
{
// Spot.Market | Spot market info endpoints
client.Spot.Market.GetBookPrice("BTCUSDT");
// Spot.Order | Spot order info endpoints
client.Spot.Order.GetAllOrders("BTCUSDT");
// Spot.System | Spot system endpoints
client.Spot.System.GetExchangeInfo();
// Spot.UserStream | Spot user stream endpoints. Should be used to subscribe to a user stream with the socket client
client.Spot.UserStream.StartUserStream();
// Spot.Futures | Transfer to/from spot from/to the futures account + cross-collateral endpoints
//client.Spot.Futures.TransferFuturesAccount("ASSET", 1, FuturesTransferType.FromSpotToUsdtFutures);
//// FuturesCoin | Coin-M general endpoints
//client.FuturesCoin.GetPositionInformation();
//// FuturesCoin.Market | Coin-M futures market endpoints
//client.FuturesCoin.Market.GetBookPrices("BTCUSD");
//// FuturesCoin.Order | Coin-M futures order endpoints
//client.FuturesCoin.Order.GetMyTrades();
//// FuturesCoin.Account | Coin-M account info
//client.FuturesCoin.Account.GetAccountInfo();
//// FuturesCoin.System | Coin-M system endpoints
//client.FuturesCoin.System.GetExchangeInfo();
//// FuturesCoin.UserStream | Coin-M user stream endpoints. Should be used to subscribe to a user stream with the socket client
//client.FuturesCoin.UserStream.StartUserStream();
//// FuturesUsdt | USDT-M general endpoints
//client.FuturesUsdt.GetPositionInformation();
//// FuturesUsdt.Market | USDT-M futures market endpoints
//client.FuturesUsdt.Market.GetBookPrices("BTCUSDT");
//// FuturesUsdt.Order | USDT-M futures order endpoints
//client.FuturesUsdt.Order.GetMyTrades("BTCUSDT");
//// FuturesUsdt.Account | USDT-M account info
//client.FuturesUsdt.Account.GetAccountInfo();
//// FuturesUsdt.System | USDT-M system endpoints
//client.FuturesUsdt.System.GetExchangeInfo();
//// FuturesUsdt.UserStream | USDT-M user stream endpoints. Should be used to subscribe to a user stream with the socket client
//client.FuturesUsdt.UserStream.StartUserStream();
// General | General/account endpoints
client.General.GetAccountInfo();
// Lending | Lending endpoints
client.Lending.GetFlexibleProductList();
//// Margin | Margin general/account info
//client.Margin.GetMarginAccountInfo();
//// Margin.Market | Margin market endpoints
//client.Margin.Market.GetMarginPairs();
//// Margin.Order | Margin order endpoints
//client.Margin.Order.GetAllMarginAccountOrders("BTCUSDT");
//// Margin.UserStream | Margin user stream endpoints. Should be used to subscribe to a user stream with the socket client
//client.Margin.UserStream.StartUserStream();
//// Margin.IsolatedUserStream | Isolated margin user stream endpoints. Should be used to subscribe to a user stream with the socket client
//client.Margin.IsolatedUserStream.StartIsolatedMarginUserStream("BTCUSDT");
//// Mining | Mining endpoints
//client.Mining.GetMiningCoinList();
//// SubAccount | Sub account management
//client.SubAccount.TransferSubAccount("fromEmail", "toEmail", "asset", 1);
//// Brokerage | Brokerage management
//client.Brokerage.CreateSubAccountAsync();
//// WithdrawDeposit | Withdraw and deposit endpoints
//client.WithdrawDeposit.GetWithdrawalHistory();
}
var socketClient = new BinanceSocketClient();
// Spot | Spot market and user subscription methods
socketClient.Spot.SubscribeToAllBookTickerUpdates(data =>
{
// Handle data
});
// FuturesCoin | Coin-M futures market and user subscription methods
socketClient.FuturesCoin.SubscribeToAllBookTickerUpdates(data =>
{
// Handle data
});
// FuturesUsdt | USDT-M futures market and user subscription methods
socketClient.FuturesUsdt.SubscribeToAllBookTickerUpdates(data =>
{
// Handle data
});
// Unsubscribe
socketClient.UnsubscribeAll();
Console.ReadLine();
}
internal BinanceSocketClientFuturesUsdt(Log log, BinanceSocketClient baseClient,
BinanceSocketClientOptions options) : base(log, baseClient)
{
BaseAddress = options.BaseAddressUsdtFutures;
}
public void AtualizaInformacoesResumo()
{
List <EntMoeda> listaMoedas = new BllMoeda().ObterTodos("", "", 1);
foreach (EntMoeda objMoeda in listaMoedas)
{
if (objMoeda.OperacaoCompraAberta.IdOperacao > 0)
{
objMoeda.OperacaoCompraAberta = new BllOperacao().ObterPorId(objMoeda.OperacaoCompraAberta.IdOperacao);
}
if (objMoeda.OperacaoVendaAberta.IdOperacao > 0)
{
objMoeda.OperacaoVendaAberta = new BllOperacao().ObterPorId(objMoeda.OperacaoVendaAberta.IdOperacao);
}
}
BinanceClient.SetDefaultOptions(new BinanceClientOptions()
{
ApiCredentials = new ApiCredentials(ConfigurationManager.AppSettings["BinanceClientKey"], ConfigurationManager.AppSettings["BinanceSecretKey"]),
LogVerbosity = LogVerbosity.Warning,
LogWriters = new List <TextWriter> {
Console.Out
}
});
BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions()
{
ApiCredentials = new ApiCredentials(ConfigurationManager.AppSettings["BinanceClientKey"], ConfigurationManager.AppSettings["BinanceSecretKey"]),
LogVerbosity = LogVerbosity.Warning,
LogWriters = new List <TextWriter> {
Console.Out
}
});
client = new BinanceClient();
/*foreach (EntMoeda moeda in listaMoedas)
* {
* if (moeda.IdMoeda == EntMoeda.MOEDA_ETH)
* {
* MonitorarVenda(moeda, new EntCarteira());
* }
* }*/
foreach (EntMoeda moeda in listaMoedas)
{
AtualizaInformacoesResumoMoeda(moeda);
CalculaRsi(moeda);
}
while (true)
{
if (DateTime.Now.Subtract(DataUltimaAtualizacao).TotalMilliseconds / 1000 >= StringUtils.ToInt(ConfigurationManager.AppSettings["SegundosAtualizacaoResumo"]))
{
DataUltimaAtualizacao = DateTime.Now;
foreach (EntMoeda moeda in listaMoedas)
{
AtualizaInformacoesResumoMoeda(moeda);
CalculaRsi(moeda);
}
}
System.Threading.Thread.Sleep(5 * 1000);
}
}
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();
}
static async Task BinanceUnsubscribe(BinanceSocketClient sock, UpdateSubscription subscription)
{
await sock.Unsubscribe(subscription);
}
internal BinanceSocketClientFutures(Log log, BinanceSocketClient baseClient)
{
Log = log;
BaseClient = baseClient;
}
public MainViewModel()
{
MainViewModel.MainViewModels.Add(this);
BinanceDefaults.SetDefaultLogVerbosity(Logging.LogVerbosity.Warning);
TextWriter tw = new StreamWriter("log.txt"); // This is not threadsafe!
BinanceDefaults.SetDefaultLogOutput(tw);
// DB
storage = new Storage();
// Load key and secret
string configLocation = "config.ini";
if (File.Exists(configLocation))
{
mainConfig = File.ReadAllLines(configLocation).ToDictionary(line => line.Split('=')[0], line => line.Split('=')[1].Trim());
var apiKey = mainConfig.GetValue("APIKey");
var apiSecret = mainConfig.GetValue("APISecret");
if (!string.IsNullOrWhiteSpace(apiKey))
{
ApiKey = apiKey;
}
if (!string.IsNullOrWhiteSpace(apiSecret))
{
ApiSecret = apiSecret;
}
}
else
{
mainConfig = new Dictionary <string, string>();
mainConfig.Add("APIKey", "");
mainConfig.Add("APISecret", "");
File.WriteAllLines(configLocation, mainConfig.Select(kvp => $"{kvp.Key}={kvp.Value}").ToList());
}
// Should be done with DI
messageBoxService = new MessageBoxService();
orderLock = new object();
BuyCommand = new DelegateCommand(Buy);
SellCommand = new DelegateCommand(Sell);
CancelCommand = new DelegateCommand(Cancel);
SettingsCommand = new DelegateCommand(Settings);
CloseSettingsCommand = new DelegateCommand(CloseSettings);
binanceSocketClient = new BinanceSocketClient();
var allSymbolsTask = Task.Run(() => GetAllSymbols());
SubscribeUserStream();
allSymbolsTask.Wait();
Task.Run(() =>
{
// Doing this voilates the ratelimit
//GetAllHistory("BTC");
//GetAllHistory("ETH");
//GetAllHistory("USDT");
//GetAllHistory("BNB");
});
}
internal BinanceSocketClientFuturesCoin(Log log, BinanceSocketClient baseClient,
BinanceSocketClientOptions options) : base(log, baseClient, options)
{
BaseAddress = options.BaseAddressCoinFutures;
}
private void BinanceFun(ViewData item)
{
using (var BinanceSocketClient = new BinanceSocketClient())
{
//var BTCUSDTDepth = BinanceSocketClient.SubscribeToDepthStream(item.Currency, (data) =>
//{
// var AsksMin = data.Asks.OrderBy(x => x.Price)?.FirstOrDefault()?.Price;
// var AsksMax = data.Asks.OrderByDescending(x => x.Price)?.FirstOrDefault()?.Price;
// var BidsMin = data.Bids.OrderBy(x => x.Price)?.FirstOrDefault()?.Price;
// var BidsMax = data.Bids.OrderByDescending(x => x.Price)?.FirstOrDefault()?.Price;
// if (TempOder == 0 && AsksMin.HasValue)
// {
// TempOder = AsksMin.Value;
// ListMsg.Insert(0, new Memo { Msg = "買入：" + TempOder });
// var sourceMemo = new BindingSource();
// sourceMemo.DataSource = ListMsg;
// SysHelper.Print(dataGridViewMemo, sourceMemo);
// }
// else if (BidsMin > (TempOder * (1 + (0.5M / 100))))
// {
// ListMsg.Insert(0, new Memo { Msg = "已賣出：" + BidsMin });
// var sourceMemo = new BindingSource();
// sourceMemo.DataSource = ListMsg;
// SysHelper.Print(dataGridViewMemo, sourceMemo);
// }
//});
var successSymbol = BinanceSocketClient.SubscribeToPartialBookDepthStream(item.Currency, 5, (data) =>
{
//dataGridViewMoney.DataSource = null;
try
{
var Ask = data.Asks.Min(x => x.Price) * Ratio; //賣出價
var Bid = data.Bids.Max(x => x.Price) * Ratio; //買入價
if (Ask > item.Ask)
{
item.StatusAsk = "上漲";
}
else
{
item.StatusAsk = "下跌";
}
if (Bid > item.Bid)
{
item.StatusBid = "上漲";
}
else
{
item.StatusBid = "下跌";
}
item.Ask = Ask; //賣出價
item.Bid = Bid; //買入價
var sourceMoney = new BindingSource();
sourceMoney.DataSource = ListVal;
SysHelper.Print(dataGridViewMoney, sourceMoney);
}
catch (Exception)
{
}
});
}
}
// Args = [Asset][Currency][start][end][gekko location]
static void Main(string[] args)
{
string asset;
string currency;
string start;
string end;
string gekkoLocation;
if (args.Length < 4)
{
//TODO: print help
Console.WriteLine("please pass these parameters [asset][currency][start][end][gekko location]");
return;
}
else
{
asset = args[0];
currency = args[1];
start = args[2];
end = args[3];
gekkoLocation = args[4];
}
//asset = "ETH";
//currency = "BTC";
//start = "2017-12-08";
//end = "2018-1-10";
//gekkoLocation = @"C:\gekko";
var binanceDBLocation = Path.Combine(gekkoLocation, "history", "binance_0.1.db");
var symbol = asset + currency;
var startTime = DateTime.Parse(start).ToUniversalTime();
var endTime = DateTime.Parse(end).ToUniversalTime();
Console.WriteLine($"Getting Candles for {asset}|{currency}");
Console.WriteLine($"From {startTime} to {endTime}");
Console.WriteLine($"Storing to \"{binanceDBLocation}\" [Exists: {File.Exists(binanceDBLocation)}]");
BinanceDefaults.SetDefaultLogOutput(Console.Out);
SQLiteConnection dbConnection = null;
try
{
dbConnection = new SQLiteConnection($"Data Source={binanceDBLocation};Version=3;");
dbConnection.Open();
Console.Write("Making Sure Table Exists...");
var ensureTableSQL = $"CREATE TABLE IF NOT EXISTS candles_{asset}_{currency} ( id INTEGER PRIMARY KEY AUTOINCREMENT, start INTEGER UNIQUE, open REAL NOT NULL, high REAL NOT NULL, low REAL NOT NULL, close REAL NOT NULL, vwp REAL NOT NULL, volume REAL NOT NULL, trades INTEGER NOT NULL )";
var ensureTableCommand = new SQLiteCommand(ensureTableSQL, dbConnection);
ensureTableCommand.ExecuteNonQuery();
Console.WriteLine("Does now.");
using (var client = new BinanceClient())
using (var socketClient = new BinanceSocketClient())
{
//Do this for every 2 weeks at a time. Binance limit is 500 on klines
DateTime segmentStartTime = startTime;
DateTime segmentEndTime = startTime.AddDays(14);
bool done = false;
for (int week = 1; !done; week++)
{
if (segmentEndTime >= endTime)
{
segmentEndTime = endTime;
done = true;
}
Console.Write($"Getting candles for period [{segmentStartTime.ToString("yyyy-MM-dd hh:mm")}]-[{segmentEndTime.ToString("yyyy-MM-dd hh:mm")}]...");
var klines = client.GetKlines(symbol, KlineInterval.OneHour, startTime: segmentStartTime, endTime: segmentEndTime);
if (klines.Success)
{
Console.Write($"Got {klines.Data.Count()} candles.");
if (klines.Data.Length == 0)
{
Console.WriteLine("Nothing to save.");
continue;
}
// Doesn't calculate Volume Weighted Price
string sql = $"replace into candles_{asset}_{currency} (start, open, high, low, close, vwp, volume, trades) values "
+ string.Join(",", klines.Data.Select(k => $"(\"{k.OpenTime.ToFileTimeUtc().ToString()}\",\"{k.Open}\",\"{k.High}\",\"{k.Low}\",\"{k.Close}\",\"{k.Open}\",\"{k.Volume}\",\"{k.Trades}\")").ToArray())
+ ";";
Console.Write("Saving to DB...");
var command = new SQLiteCommand(sql, dbConnection);
command.ExecuteNonQuery();
Console.WriteLine("Saved.");
}
else
{
Console.WriteLine($"Could not get klines\nCode: {klines.Error.Code}\nMessage: {klines.Error.Message}");
return;
}
// jump forward 2 weeks
segmentStartTime = segmentEndTime;
segmentEndTime = segmentEndTime.AddDays(14);
}
}
Console.WriteLine("Finished.");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
dbConnection?.Close();
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey(true);
}
public TradeResult TrailingStopLoss(Trade trade)
{
bool canceledSwap = false;
int iterationCanceled = 0;
bool active = true;
int priceDecimal = BitConverter.GetBytes(decimal.GetBits(trade.StopLossPrice)[3])[2];
decimal prevStopLossPrice = build.StopLossPrice;
decimal percentStop = decimal.Round((build.StopLossPrice - build.Price) / build.Price * -1, 3);
TradeResult result = new TradeResult();
using (var client = new BinanceSocketClient())
{
var successKline = client.SubscribeToKlineStream(build.Market, KlineInterval.OneMinute, (data) =>
{
if (trade.Status && iterationCanceled == 0)
{
decimal newPercentDiff = decimal.Round((trade.StopLossPrice - data.Data.High) / data.Data.High, 3);
newPercentDiff = newPercentDiff < 0 ? newPercentDiff * -1m : newPercentDiff;
if (newPercentDiff > percentStop)
{
trade.StopLossPrice = decimal.Round(data.Data.High - (data.Data.High * percentStop), priceDecimal);
Cancel cancel = new Cancel();
if (cancel.Trade(trade))
{
canceledSwap = true;
Sell sell = new Sell(build, api);
trade = sell.LimitStop(trade, trade.StopLossPrice);
if (trade.Success)
{
canceledSwap = false;
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
}
}
}
}
});
while (active)
{
using (var db = new ApplicationDbContext())
{
Trade tradeGrab = db.Trades.Where(t => t.Id == trade.Id).Single();
if (!tradeGrab.Status)
{
trade.Status = false;
}
}
using (var clientRest = new BinanceClient())
{
var orderStatus = clientRest.QueryOrder(build.Market, trade.OrderId);
if (orderStatus.Success)
{
if (orderStatus.Data.Status == OrderStatus.Filled)
{
result.SellPrice = orderStatus.Data.Price;
result.SellOrderId = trade.OrderId;
result.TradeId = trade.Id;
result.EndTime = DateTime.Now;
CalculateResult calculate = new CalculateResult();
result = calculate.PercentDifference(result, trade);
result.Success = true;
active = false;
}
if (orderStatus.Data.Status == OrderStatus.Canceled && !canceledSwap)
{
iterationCanceled++;
if (iterationCanceled > 4)
{
active = false;
trade.Status = false;
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
}
System.Threading.Thread.Sleep(5000);
}
else if (orderStatus.Data.Status != OrderStatus.Canceled)
{
iterationCanceled = 0;
}
}
}
}
}
return(result);
}
internal BinanceSocketClientBlvt(Log log, BinanceSocketClient baseClient, BinanceSocketClientOptions options)
{
_log = log;
_baseClient = baseClient;
_baseAddress = options.BaseAddressUsdtFutures;
}
public TradeResult MiddleOrderFlip(Trade trade)
{
// Take Profit Stop Loss Trailing Stop Loss
decimal middle = build.TakeProfitPrice - ((build.TakeProfitPrice - build.StopLossPrice) / 2);
bool active = true;
bool canceledSwap = false;
bool take = true;
bool initial = true;
bool trailingTake = false;
int iterationCanceled = 0;
int priceDecimal = BitConverter.GetBytes(decimal.GetBits(trade.StopLossPrice)[3])[2];
decimal prevStopLossPrice = build.StopLossPrice;
decimal percentStop = decimal.Round((build.StopLossPrice - build.Price) / build.Price * -1m, 2);
TradeResult result = new TradeResult();
using (var client = new BinanceSocketClient())
{
var successKline = client.SubscribeToKlineStream(build.Market, KlineInterval.OneMinute, (data) =>
{
if (trade.Status && iterationCanceled == 0)
{
if (build.TrailingStopLoss)
{
if (((trade.StopLossPrice - data.Data.High) / data.Data.High * -1) > percentStop)
{
prevStopLossPrice = trade.StopLossPrice;
trade.StopLossPrice = decimal.Round(data.Data.High - (data.Data.High * percentStop), priceDecimal);
middle = trade.TakeProfitPrice - ((trade.TakeProfitPrice - trade.StopLossPrice) / 2);
}
}
if (data.Data.Low > middle && !take)
{
if (!build.TrailingTakeProfit)
{
Cancel cancel = new Cancel();
if (cancel.Trade(trade))
{
canceledSwap = true;
Sell sell = new Sell(build, api);
trade = sell.Limit(trade, trade.TakeProfitPrice);
if (trade.Success)
{
canceledSwap = false;
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
take = true;
}
}
}
else if (data.Data.High > trade.TakeProfitPrice)
{
trailingTake = true;
}
}
else if (data.Data.Low <= middle && take || data.Data.Low <= middle && initial || trade.StopLossPrice > prevStopLossPrice && data.Data.Low <= middle)
{
Cancel cancel = new Cancel();
if (cancel.Trade(trade) || initial)
{
canceledSwap = true;
Sell sell = new Sell(build, api);
trade = sell.LimitStop(trade, trade.StopLossPrice);
if (trade.Success)
{
canceledSwap = false;
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
take = false;
}
}
}
initial = false;
}
});
while (active && !trailingTake)
{
using (var db = new ApplicationDbContext())
{
Trade tradeGrab = db.Trades.Where(t => t.Id == trade.Id).Single();
if (!tradeGrab.Status)
{
trade.Status = false;
}
}
using (var clientRest = new BinanceClient())
{
var orderStatus = clientRest.QueryOrder(build.Market, trade.OrderId);
if (orderStatus.Success)
{
if (orderStatus.Data.Status == OrderStatus.Filled)
{
result.SellPrice = orderStatus.Data.Price;
result.SellOrderId = trade.OrderId;
result.TradeId = trade.Id;
result.EndTime = DateTime.Now;
CalculateResult calculate = new CalculateResult();
result = calculate.PercentDifference(result, trade);
result.Success = true;
active = false;
}
if (orderStatus.Data.Status == OrderStatus.Canceled && !canceledSwap)
{
iterationCanceled++;
if (iterationCanceled > 4)
{
active = false;
trade.Status = false;
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
}
System.Threading.Thread.Sleep(5000);
}
else if (orderStatus.Data.Status != OrderStatus.Canceled)
{
iterationCanceled = 0;
}
}
}
}
}
if (trailingTake == true)
{
decimal trailingTakePerc = build.TrailingTakePercent < 0 ? build.TrailingTakePercent * -1m : build.TrailingTakePercent;
trade.StopLossPrice = decimal.Round(build.TakeProfitPrice - (build.TakeProfitPrice * (trailingTakePerc / 100)), priceDecimal);
trade.IsTrailingTake = true;
trade.DisplayType = "TSLVC";
TradeDB tradeDB = new TradeDB();
tradeDB.Update(trade);
return(TrailingStopLoss(trade));
}
else
{
return(result);
}
}
public void Start(string[] args)
{
LoadKeyAndSecret();
if (HasKeyAndSecret)
{
BinanceDefaults.SetDefaultApiCredentials(APIKey, APISecret);
}
BinanceDefaults.SetDefaultLogVerbosity(LogVerbosity.Debug);
BinanceDefaults.SetDefaultLogOutput(Console.Out);
using (var client = new BinanceClient())
using (var socketClient = new BinanceSocketClient())
{
// Public
var ping = client.Ping();
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 prices24h = client.Get24HPrice("BNBBTC");
var allPrices = client.GetAllPrices();
var allBookPrices = client.GetAllBookPrices();
if (HasKeyAndSecret)
{
// 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");
}
if (HasKeyAndSecret)
{
// Withdrawal/deposit
var withdrawalHistory = client.GetWithdrawHistory();
var depositHistory = client.GetDepositHistory();
var withdraw = client.Withdraw("ASSET", "ADDRESS", 0);
}
// 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
});
if (HasKeyAndSecret)
{
var successStart = client.StartUserStream();
var successAccount = socketClient.SubscribeToAccountUpdateStream(successStart.Data.ListenKey, (data) =>
{
// handle data
});
var successOrder = socketClient.SubscribeToOrderUpdateStream(successStart.Data.ListenKey, (data) =>
{
// handle data
});
}
socketClient.UnsubscribeFromStream(successDepth.Data);
socketClient.UnsubscribeFromAccountUpdateStream();
socketClient.UnsubscribeAllStreams();
}
Console.WriteLine("Finished, Press and key to continue...");
Console.ReadKey(true);
}
public void SubscribingToDepthStream_Should_TriggerWhenDepthStreamMessageIsReceived()
{
// arrange
var socket = new Mock <IWebsocket>();
socket.Setup(s => s.Close());
socket.Setup(s => s.Connect());
socket.Setup(s => s.Url).Returns("test");
socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>()));
var factory = new Mock <IWebsocketFactory>();
factory.Setup(s => s.CreateWebsocket(It.IsAny <string>())).Returns(socket.Object);
BinanceStreamDepth result = null;
var client = new BinanceSocketClient {
SocketFactory = factory.Object
};
var subscibtion = client.SubscribeToDepthStream("test", (test) => result = test);
var data = new BinanceStreamDepth()
{
Event = "TestDepthStream",
EventTime = new DateTime(2017, 1, 1),
Symbol = "test",
UpdateId = 1,
Asks = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 1.1, Quantity = 2.2
},
new BinanceOrderBookEntry()
{
Price = 3.3, Quantity = 4.4
}
},
Bids = new List <BinanceOrderBookEntry>()
{
new BinanceOrderBookEntry()
{
Price = 5.5, Quantity = 6.6
},
new BinanceOrderBookEntry()
{
Price = 7.7, Quantity = 8.8
}
}
};
// act
socket.Raise(r => r.OnMessage += null, new MessagedEventArgs(JsonConvert.SerializeObject(data), false, false, true, new byte[2]));
// assert
Assert.IsTrue(subscibtion.Success);
Assert.IsTrue(subscibtion.Data != 0);
Assert.IsNotNull(result);
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data, result, "Bids", "Asks"));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Asks[0], result.Asks[0]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Asks[1], result.Asks[1]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Bids[0], result.Bids[0]));
Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data.Bids[1], result.Bids[1]));
}
static void Main(string[] args)
{
var client = new BinanceClient(new BinanceClientOptions
{
ApiCredentials = new ApiCredentials("qzQApE9sTemaP6Qda3eGW4n3HLOfp1LaQ6Q4ZFS1kA7qTSOCVJeISD7G4JBQsR4b", "w0hkzxOyyB4ryGjR2aiAQtgqqBbydG8RQ2Zs5fNJCcJCH4rtiW5zs8fs7EQ7Yh6r")
});
var generalInfo = client.General.GetAccountInfo().Data;
#if USE_SPOT_ACCOUNT
Console.WriteLine("===== Spot account =========");
foreach (var bal in generalInfo.Balances)
{
if (bal.Free > (decimal)0.0)
{
Console.WriteLine(string.Format("{0} - {1}", bal.Asset, bal.Free));
}
}
#endif
// var accStatus = client.General.GetAccountStatus().Data;
Console.WriteLine("===== Future account =========");
#if USE_FUTURE_ACCOUNT
var futureAccountcSnapshot = client.General.GetDailyFutureAccountSnapshot().Data;
foreach (var sn in futureAccountcSnapshot)
{
foreach (var asset in sn.Data.Assets)
{
Console.WriteLine(string.Format("{0} {1} Margin: {2} Wallet: {3}", sn.Timestamp.ToString(), asset.Asset, asset.MarginBalance, asset.WalletBalance));
}
}
#endif
//#if USE_FUTURE_COIN_SYMB
GetAllFutureCoinSymbols(client);
//#endif
/// var log = new Log("test");
// var opt = new BinanceSocketClientOptions();
// //var wsclientfc = new BinanceSocketClient();
// wsclientfc.FuturesCoin.SubscribeToOrderBookUpdatesAsync()
var startResult = client.Spot.UserStream.StartUserStream();
// if (!startResult.Success)
// throw new Exception($"Failed to start spot user stream: {startResult.Error}");
// startResult = client.FuturesCoin.UserStream.StartUserStream();
//if (!startResult.Success)
// throw new Exception($"Failed to start FuturesCoin user stream: {startResult.Error}");
#if USE_ORDERBOOK
using (var wsclient = new BinanceSocketClient())
{
var successTrades = wsclient.FuturesCoin.SubscribeToOrderBookUpdatesAsync("ethusd_perp", 500, (msg) => {
Console.WriteLine($" {msg.Symbol}");
foreach (var ask in msg.Asks)
{
Console.WriteLine($"ask:{ask.Price} {ask.Quantity}");
}
foreach (var bid in msg.Bids)
{
Console.WriteLine($"bid:{bid.Price} {bid.Quantity}");
}
});
}
#endif
#if USE_AGGTRADE
using (var wsclient = new BinanceSocketClient())
{
var successTrades = wsclient.FuturesCoin.SubscribeToAggregatedTradeUpdatesAsync("adausd_perp", (msg) => {
Console.WriteLine($" {msg.Symbol} price:{msg.Price} Q:{msg.Quantity} BuyerMaker:{msg.BuyerIsMaker}");
});
}
#endif
// future transactions
using (var wsclient = new BinanceSocketClient())
{
Console.WriteLine("Subscribe to User Data");
var successTrades = wsclient.FuturesCoin.SubscribeToUserDataUpdatesAsync("adause_perp",
(marginData) =>
{
foreach (var pos in marginData.Positions)
{
Console.WriteLine($"{pos.Symbol} : Amount={pos.PositionAmount} ");
}
},
(accData) =>
{
var updateData = accData.UpdateData;
foreach (var pos in accData.UpdateData.Positions)
{
Console.WriteLine($"{pos.Symbol} Entry:{pos.EntryPrice} Amount:{ pos.PositionAmount } PnL:{pos.RealizedPnL} Side:{pos.PositionSide} MarginType:{pos.MarginType} {pos.EntryPrice} ");
}
},
(orderData) =>
{
var data = orderData.UpdateData;
Console.WriteLine($"{data.Symbol} Quantity:{data.Quantity} Price:{data.Price} PosSide:{data.PositionSide} Side:{data.Side} Commision:{data.Commission} CommisionAsset:{data.CommissionAsset} Avg Price:{data.AveragePrice} BuyerIsMaker:{data.BuyerIsMaker} ");
},
(keyEvent) =>
{
Console.WriteLine($"{keyEvent.EventTime} {keyEvent.Event}");
});
if (client.FuturesUsdt.UserStream.StartUserStream().Success)
{
Console.WriteLine("UserStream Start");
}
}
//var socketClient = new BinanceSocketClient();
//// subscribe to updates on the spot API
// socketClient.Spot.SubscribeToBookTickerUpdates("BTCUSDT", data => {
// Console.WriteLine(data.BestBidQuantity);
// // Handle data
//});
Console.Write("\nPress Any Key To Stop Streaming");
Console.ReadKey();
client.FuturesUsdt.UserStream.StopUserStream("ethusdt");
Console.Write("\nPress Any Key To Exit");
Console.ReadKey();
//var startResult = client.Spot.UserStream.StartUserStream();
//if (!startResult.Success)
// throw new Exception($"Failed to start user stream: {startResult.Error}");
//var socketClient = new BinanceSocketClient();
// socketClient.Spot.SubscribeToTradeUpdatesAsync(startResult.Data,
// accountUpdate => { // Handle account info update
//},
// orderUpdate => { // Handle order update
//},
// ocoUpdate => { // Handle oco order update
//},
// positionUpdate => { // Handle account position update
//},
// balanceUpdate => { // Handle balance update
//});
}
