I've added a bit of functionality.
- We entered the variables as properties and made them automatically reflected.
- In addition to the beat coin, you can buy and sell with other currencies.
Huh ~ It's not easy ... ^^
package com.binance.trading;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import com.binance.api.client.BinanceApiClientFactory;
import com.binance.api.client.BinanceApiRestClient;
import com.binance.api.client.domain.account.Account;
import com.binance.api.client.domain.account.AssetBalance;
import com.binance.api.client.domain.account.NewOrder;
import com.binance.api.client.domain.account.Order;
import com.binance.api.client.domain.account.Trade;
import com.binance.api.client.domain.account.request.OrderRequest;
import com.binance.api.client.domain.general.ExchangeInfo;
import com.binance.api.client.domain.general.FilterType;
import com.binance.api.client.domain.general.SymbolFilter;
import com.binance.api.client.domain.general.SymbolInfo;
import com.binance.api.client.domain.market.TickerPrice;
import com.binance.api.client.exception.BinanceApiException;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.pengrad.telegrambot.TelegramBot;
import com.pengrad.telegrambot.request.SendMessage;
/**
* Examples on how to get market data information such as the latest price of a
* symbol, etc.
*/
public class MarketOrderTrading extends TimerTask {
private final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
private final String ITEMS_FILE_NAME = "trading_items.json";
private final String CONFIG_FILE_NAME = "tradingBinance.properties";
private final long CONFIG_REFLESH_DELAY_MILLISECONDS = 60000;
private final Type ITEMS_TYPE = new TypeToken<Map<String, TradingItems>>() {}.getType();
private final String API_KEY = "API_KEY";
private final String SECRET_KEY = "SECRET_KEY";
private final String TELEGRAM_TOKEN = "TELEGRAM_TOKEN";
private final String TELEGRAM_CHAT_ID = "TELEGRAM_CHAT_ID";
private final PropertiesConfiguration config = new PropertiesConfiguration();
private final FileChangedReloadingStrategy fileChangedReloadingStrategy =new FileChangedReloadingStrategy();
private static String[] PAIR_SYMBOLS = null;
private final Map<String, Double> CURRENCY_INVEST_PRICES = new HashMap<String, Double>();
private double GAP_TRADING_PERCENT = 70.0;
private boolean IS_RISK_TASKING = false;
private double FEE_PERCENT = 0.05;
private double TAKE_EXTRA_PERCENT = 2.0;
private double MIN_START_PERCENT = 1.0;
private static int TIME_PERIOD_MILLISECONDS = 500;
private final Map<String, Double> MIN_ORDER_VALUES = new HashMap<String, Double>();
private int STATUS_LOGGING_CYCLE = 600;
private final BinanceApiClientFactory factory = BinanceApiClientFactory.newInstance(API_KEY, SECRET_KEY);
private final BinanceApiRestClient client = factory.newRestClient();
private final TelegramBot telegramBot = new TelegramBot(TELEGRAM_TOKEN);
private Map<String, TradingItems> items = null;
private long exeCount = 0;
private FileWriter fw;
public MarketOrderTrading() {
loadConfig();
initialSettings();
}
private void loadConfig() {
config.setFileName(CONFIG_FILE_NAME);
try {
config.load();
setConfig();
} catch (ConfigurationException e) {
sendLogging(e.getMessage());
e.printStackTrace();
}
fileChangedReloadingStrategy.setRefreshDelay(CONFIG_REFLESH_DELAY_MILLISECONDS);
config.setReloadingStrategy(fileChangedReloadingStrategy);
}
private void setConfig() {
PAIR_SYMBOLS = config.getStringArray("PAIR_SYMBOLS");
CURRENCY_INVEST_PRICES.put("BTC", config.getDouble("CURRENCY_INVEST_PRICES.BTC", 0.002));
CURRENCY_INVEST_PRICES.put("ETH", config.getDouble("CURRENCY_INVEST_PRICES.ETH", 0.02));
CURRENCY_INVEST_PRICES.put("USDT", config.getDouble("CURRENCY_INVEST_PRICES.USDT", 11.0));
CURRENCY_INVEST_PRICES.put("BNB", config.getDouble("CURRENCY_INVEST_PRICES.BNB", 2.0));
GAP_TRADING_PERCENT = config.getDouble("GAP_TRADING_PERCENT", 70.0);
IS_RISK_TASKING = config.getBoolean("IS_RISK_TASKING", false);
FEE_PERCENT = config.getDouble("FEE_PERCENT", 0.05);
TAKE_EXTRA_PERCENT = config.getDouble("TAKE_EXTRA_PERCENT", 0.05);
MIN_START_PERCENT = config.getDouble("MIN_START_PERCENT", 1.0);
TIME_PERIOD_MILLISECONDS = config.getInt("TIME_PERIOD_MILLISECONDS", 500);
MIN_ORDER_VALUES.put("BTC", config.getDouble("MIN_ORDER_VALUES.BTC", 0.001));
MIN_ORDER_VALUES.put("ETH", config.getDouble("MIN_ORDER_VALUES.ETH", 0.01));
MIN_ORDER_VALUES.put("USDT", config.getDouble("MIN_ORDER_VALUES.USDT", 10.0));
MIN_ORDER_VALUES.put("BNB", config.getDouble("MIN_ORDER_VALUES.BNB", 1.0));
STATUS_LOGGING_CYCLE = config.getInt("STATUS_LOGGING_CYCLE");
}
private void initialSettings() {
if (items == null) {
loadItems();
}
final Iterator<String> itemKeys = items.keySet().iterator();
while (itemKeys.hasNext()) {
final String key = itemKeys.next();
if ( ArrayUtils.contains(PAIR_SYMBOLS, key) == false ) {
itemKeys.remove();
}
}
for (int i = 0; i < PAIR_SYMBOLS.length; i++) {
final String pairSymbol = PAIR_SYMBOLS[i];
if (items.containsKey(pairSymbol) == false) {
initialBasicSetting(pairSymbol);
initialSetting(items.get(pairSymbol));
}
}
}
private void initialBasicSetting(final String pairSymbol) {
TradingItems item;
if (items.containsKey(pairSymbol)) {
item = this.items.get(pairSymbol);
} else {
item = new TradingItems();
items.put(pairSymbol, item);
}
final String[] symbols = StringUtils.split(pairSymbol, '/');
item.setTargetSymbol(symbols[0]);
item.setCurrencySymbol(symbols[1]);
item.setPairSymbol(symbols[0] + symbols[1]);
getLotSize(item);
}
private void initialSetting(final TradingItems item) {
final List<Order> openOrders = getOpenOrders(item.getPairSymbol());
if (openOrders.size() > 0) {
item.setWaiting(true);
return;
} else {
item.setWaiting(false);
}
final TickerPrice nowTickerPrice = getPrice(item.getPairSymbol());
final double nowPrice = Double.parseDouble(nowTickerPrice.getPrice());
Trade trade = getLastTrade(item.getPairSymbol());
double bagicPrice = 0.0;
if (trade != null) {
bagicPrice = Double.parseDouble(trade.getPrice());
} else {
bagicPrice = nowPrice;
}
item.setTopPrice(bagicPrice);
item.setBottomPrice(bagicPrice);
item.setLastOrderPrice(bagicPrice);
sendLogging(item.getPairSymbol() + ", Bagic Price : " + toString(bagicPrice), false);
}
private void getLotSize(final TradingItems item) {
final ExchangeInfo exchangeInfo = client.getExchangeInfo();
final SymbolInfo symbolInfo = exchangeInfo.getSymbolInfo(item.getPairSymbol());
final SymbolFilter priceFilter = symbolInfo.getSymbolFilter(FilterType.LOT_SIZE);
item.setMinQty(Double.parseDouble(priceFilter.getMinQty()));
item.setStepSize(Double.parseDouble(priceFilter.getStepSize()));
}
private TickerPrice getPrice(final String pairSymbol) {
return client.getPrice(pairSymbol);
}
private List<Order> getOpenOrders(final String pairSymbol) {
return client.getOpenOrders(new OrderRequest(pairSymbol));
}
private Trade getLastTrade(final String pairSymbol) {
Trade trade = null;
List<Trade> trades = client.getMyTrades(pairSymbol, 1);
if (trades.size() > 0) {
trade = trades.get(0);
}
return trade;
}
private AssetBalance getAssetBalance(final String symbol) {
final Account account = client.getAccount(6000000L, System.currentTimeMillis());
return account.getAssetBalance(symbol);
}
private void watchTrading(final TradingItems item) {
if (item.isWaiting()) {
initialSetting(item);
return;
}
final double lastOrderPrice = item.getLastOrderPrice();
final TickerPrice nowTickerPrice = getPrice(item.getPairSymbol());
final double nowPrice = Double.parseDouble(nowTickerPrice.getPrice());
item.setNowPrice(nowPrice);
if (nowPrice < lastOrderPrice) { // Buy
item.setBuy(true);
watchBuyTrading(item);
} else { // Sell
item.setBuy(false);
watchSellTrading(item);
}
}
private void watchBuyTrading(final TradingItems item) {
final double bottomPrice = item.getBottomPrice();
final double lastOrderPrice = item.getLastOrderPrice();
final double nowPrice = item.getNowPrice();
if (nowPrice < bottomPrice) {
item.setBottomPrice(nowPrice);
} else {
if (this.IS_RISK_TASKING == false) {
final double breakEvenPrice = lastOrderPrice
- nowPrice * (TAKE_EXTRA_PERCENT + FEE_PERCENT) / 100.0;
if (nowPrice > breakEvenPrice) {
return;
}
}
if (nowPrice - bottomPrice < nowPrice * (MIN_START_PERCENT / 100)) {
return;
}
final double maxPrice = lastOrderPrice - (lastOrderPrice - bottomPrice) * (GAP_TRADING_PERCENT / 100.0);
if (nowPrice < maxPrice) {
return;
}
orderBuying(item, nowPrice);
initialSetting(item);
}
}
private void watchSellTrading(final TradingItems item) {
final double topPrice = item.getTopPrice();
final double lastOrderPrice = item.getLastOrderPrice();
final double nowPrice = item.getNowPrice();
if (nowPrice > topPrice) {
item.setTopPrice(nowPrice);
} else {
if (this.IS_RISK_TASKING == false) {
final double breakEvenPrice = lastOrderPrice
+ nowPrice * (TAKE_EXTRA_PERCENT + FEE_PERCENT * 2) / 100.0;
if (nowPrice < breakEvenPrice) {
return;
}
}
if (topPrice - nowPrice < nowPrice * (MIN_START_PERCENT / 100)) {
return;
}
final double minPrice = lastOrderPrice + (topPrice - lastOrderPrice) * (GAP_TRADING_PERCENT / 100.0);
if (nowPrice > minPrice) {
return;
}
orderSelling(item, nowPrice);
initialSetting(item);
}
}
private String getStatusLogging(final TradingItems item) {
return item.getPairSymbol() + " -- "
+ (item.isBuy() ? "Buy" : "Sell")
+ ", N:" + toString(item.getNowPrice())
+ ", T:" + toString(item.getTopPrice())
+ ", B:"+ toString(item.getBottomPrice())
+ ", L:" + toString(item.getLastOrderPrice());
}
private void sendStatusLogging() {
if (exeCount % STATUS_LOGGING_CYCLE == 0) {
final StringBuffer sb = new StringBuffer();
for (int i = 0; i < PAIR_SYMBOLS.length; i++) {
final String pairSymbol = PAIR_SYMBOLS[i];
final TradingItems item = items.get(pairSymbol);
sb.append(getStatusLogging(item)).append(System.lineSeparator());
}
sendLogging(sb.toString(), false);
}
}
private void orderBuying(final TradingItems item, final double price) {
final String currencySymbol = item.getCurrencySymbol();
final double minOrderValue = MIN_ORDER_VALUES.get(currencySymbol);
final AssetBalance currencyBalance = getAssetBalance(currencySymbol);
final double freeQty = Double.parseDouble(currencyBalance.getFree());
final double currencyInvestPrice = CURRENCY_INVEST_PRICES.get(item.getCurrencySymbol());
String buyQty = null;
if (freeQty < minOrderValue) {
sendLogging(item.getPairSymbol() + ", BTC Free Qty : " +
freeQty + " --- There is not enough currency.", false);
return;
} else if (freeQty < currencyInvestPrice) {
buyQty = toOrderQty(item, freeQty / price);
} else {
buyQty = toOrderQty(item, currencyInvestPrice / price);
}
try {
client.newOrder(NewOrder.marketBuy(item.getPairSymbol(), buyQty));
sendLogging(item.getPairSymbol() + " -- Buy : " + toString(price) + ", Qty : " + buyQty);
} catch (BinanceApiException e) {
sendLogging(e.getMessage());
e.printStackTrace();
}
}
private void orderSelling(final TradingItems item, final double price) {
final String currencySymbol = item.getCurrencySymbol();
final String targetSymbol = item.getTargetSymbol();
final double currencyInvestPrice = CURRENCY_INVEST_PRICES.get(currencySymbol);
final double minOrderValue = MIN_ORDER_VALUES.get(currencySymbol);
final AssetBalance balance = getAssetBalance(targetSymbol);
final double freeQty = Double.parseDouble(balance.getFree());
final double sellMaxQty = currencyInvestPrice / price;
final double sellMinQty = minOrderValue / price;
String sellQty = null;
if (sellMinQty > freeQty) {
sendLogging(item.getPairSymbol() + ", Free Qty : " +
freeQty + " --- There is not enough target.", false);
return;
} else if (sellMaxQty > freeQty) {
// BNB
if (StringUtils.equals("BNB", targetSymbol) || StringUtils.equals("BNB", currencySymbol)) {
sendLogging(item.getPairSymbol() + ", Free Qty : " +
freeQty + " --- There is not enough target.", false);
return;
}
sellQty = toOrderQty(item, freeQty);
} else {
sellQty = toOrderQty(item, sellMaxQty);
}
try {
client.newOrder(NewOrder.marketSell(item.getPairSymbol(), sellQty));
sendLogging(item.getPairSymbol() + " -- Sell : " + toString(price) + ", Qty : " + sellQty);
} catch (BinanceApiException e) {
sendLogging(e.getMessage());
e.printStackTrace();
}
}
private String toOrderQty(final TradingItems item, final double qty) {
String strOrderQty = null;
if (qty >= item.getMinQty()) {
double orderQty = qty - qty % item.getStepSize();
strOrderQty = toString(orderQty);
}
return strOrderQty;
}
private String toString(double num) {
return String.format("%.9f", num);
}
private void sendLogging(final String message) {
System.out.println(addDateString(message));
sendToBot(message);
}
private void sendLogging(final String message, final boolean sendBot) {
if (sendBot) {
sendLogging(message);
} else {
System.out.println(addDateString(message));
}
}
private String addDateString(final String message) {
final Date nowDate = new Date();
return message + ":: " + DATE_FORMAT.format(nowDate);
}
private void sendToBot(final String message) {
try {
final SendMessage request = new SendMessage(TELEGRAM_CHAT_ID, addDateString(message));
telegramBot.execute(request);
} catch (Exception e) {
e.printStackTrace();
}
}
private void saveItems() {
final Gson gson = new Gson();
final String jsonItems = gson.toJson(items);
try {
fw = new FileWriter(ITEMS_FILE_NAME);
fw.write(jsonItems);
fw.flush();
} catch (IOException e) {
sendLogging(e.getMessage());
e.printStackTrace();
}
}
private void loadItems() {
JsonReader reader;
Gson gson = new Gson();
try {
reader = new JsonReader(new FileReader(ITEMS_FILE_NAME));
this.items = gson.fromJson(reader, ITEMS_TYPE);
} catch (FileNotFoundException e) {
items = new HashMap<String, TradingItems>();
e.printStackTrace();
}
}
@Override
public void run() {
if (fileChangedReloadingStrategy.reloadingRequired()) {
setConfig();
initialSettings();
}
for (int i = 0; i < PAIR_SYMBOLS.length; i++) {
final String pairSymbol = PAIR_SYMBOLS[i];
final TradingItems item = items.get(pairSymbol);
watchTrading(item);
}
saveItems();
sendStatusLogging();
exeCount++;
}
public static void main(String[] args) {
final TimerTask task = new MarketOrderTrading();
final ScheduledExecutorService service =
Executors.newSingleThreadScheduledExecutor();
service.scheduleWithFixedDelay(task, TIME_PERIOD_MILLISECONDS,
TIME_PERIOD_MILLISECONDS, TimeUnit.MILLISECONDS);
}
}