Candlestick question

[gu3nter]

Hello together, I have a problem and hope you can help me (I hope that it is ok to ask here :))

I want to calculate the MACD indicator, but I´m a noob and it doesn´t work :(

I would be great, if the trader is able to get the closing price of the last 2 days. I think it´s enough for me to know how to get out the closing price of the last hour and rest i can do my own. (First I only want to print the last closing price)

What I´ve done yet:

I saw at https://github.com/joaopsilva/binance-java-api the example of the Candlestick.

List<Candlestick> candlesticks = client.getCandlestickBars("NEOETH", CandlestickInterval.WEEKLY); System.out.println(candlesticks);

My changes in the code of TradingClient.java:
I added after line 14:
import com.binance.api.client.domain.market.Candlestick; import com.binance.api.client.domain.market.CandlestickInterval;

and after new line 73:
public List<Candlestick> getCandlestickBars() { //OrderRequest request = new OrderRequest(symbol); return client.getCandlestickBars("NEOETH", CandlestickInterval.WEEKLY); }

In BinanceTrader.java:
I added after line 6:
import com.binance.api.client.domain.market.Candlestick; import com.binance.api.client.domain.market.CandlestickInterval;

and after new line 42:
Candlestick candlestick = client.getCandlestickBars(); logger.info("candlestick: " + candlestick);

When I trie to start the trader I got the following message:
/root/binance-trader/src/main/java/io/github/unterstein/BinanceTrader.java:[43,58] incompatible types: java.util.List<com.binance.api.client.domain.market.Candlestick> cannot be converted to com.binance.api.client.domain.market.Candlestick

Here the complete code of my changes:
BinanceTrader.java:
`package io.github.unterstein;

import com.binance.api.client.domain.OrderStatus;
import com.binance.api.client.domain.account.AssetBalance;
import com.binance.api.client.domain.account.Order;
import com.binance.api.client.domain.market.OrderBook;
import com.binance.api.client.domain.market.Candlestick;
import com.binance.api.client.domain.market.CandlestickInterval;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public class BinanceTrader {

private static Logger logger = LoggerFactory.getLogger(BinanceTrader.class);

private TradingClient client;
private final double tradeDifference;
private final double tradeProfit;
private final int tradeAmount;

private Double currentlyBoughtPrice;
private Long orderId;
private int panicBuyCounter;
private int panicSellCounter;
private double trackingLastPrice;

BinanceTrader(double tradeDifference, double tradeProfit, int tradeAmount, String baseCurrency, String tradeCurrency, String key, String secret) {
client = new TradingClient(baseCurrency, tradeCurrency, key, secret);
trackingLastPrice = client.lastPrice();
this.tradeAmount = tradeAmount;
this.tradeProfit = tradeProfit;
this.tradeDifference = tradeDifference;
clear();
}

void tick() {
double lastPrice = 0;
try {
OrderBook orderBook = client.getOrderBook();
Candlestick candlestick = client.getCandlestickBars();
logger.info("candlestick: " + candlestick);
lastPrice = client.lastPrice();
AssetBalance tradingBalance = client.getTradingBalance();
double lastKnownTradingBalance = client.getAllTradingBalance();
double lastBid = Double.valueOf(orderBook.getBids().get(0).getPrice());
double lastAsk = Double.valueOf(orderBook.getAsks().get(0).getPrice());
double buyPrice = lastBid + tradeDifference;
double sellPrice = lastAsk - tradeDifference;
double profitablePrice = buyPrice + (buyPrice * tradeProfit / 100);

  logger.info(String.format("buyPrice:%.8f sellPrice:%.8f bid:%.8f ask:%.8f price:%.8f profit:%.8f diff:%.8f\n", buyPrice, sellPrice, lastAsk, lastAsk, lastPrice, profitablePrice, (lastAsk - profitablePrice)));

  if (orderId == null) {
    logger.info("nothing bought, let`s check");
    // find a burst to buy
    // but make sure price is ascending!
    if (lastAsk >= profitablePrice) {
      if (lastPrice > trackingLastPrice) {
        logger.info("Buy burst detected");
        currentlyBoughtPrice = profitablePrice;
        orderId = client.buy(tradeAmount, buyPrice).getOrderId();
        panicBuyCounter = 0;
        panicSellCounter = 0;
      } else {
        logger.warn("woooops, price is falling?!? don`t do something!");
        panicSellForCondition(lastPrice, lastKnownTradingBalance, client.tradingBalanceAvailable(tradingBalance));
      }
    } else {
      logger.info(String.format("No profit detected, difference %.8f\n", lastAsk - profitablePrice));
      currentlyBoughtPrice = null;
      panicSellForCondition(lastPrice, lastKnownTradingBalance, client.tradingBalanceAvailable(tradingBalance));
    }
  } else {
    Order order = client.getOrder(orderId);
    OrderStatus status = order.getStatus();
    if (status != OrderStatus.CANCELED) {
      // not new and not canceled, check for profit
      logger.info("Tradingbalance: " + tradingBalance);
      if ("0".equals("" + tradingBalance.getLocked().charAt(0)) &&
          lastAsk >= currentlyBoughtPrice) {
        if (status == OrderStatus.NEW) {
          // nothing happened here, maybe cancel as well?
          panicBuyCounter++;
          logger.info(String.format("order still new, time %d\n", panicBuyCounter));
          if (panicBuyCounter > 4) {
            client.cancelOrder(orderId);
            clear();
          }
        } else {
          if ("0".equals("" + tradingBalance.getFree().charAt(0))) {
            logger.warn("no balance in trading money, clearing out");
            clear();
          } else if (status == OrderStatus.PARTIALLY_FILLED || status == OrderStatus.FILLED) {
            logger.info("Order filled with status " + status);
            if (lastAsk >= profitablePrice) {
              logger.info("still gaining profitable profits HODL!!");
            } else {
              logger.info("Not gaining enough profit anymore, let`s sell");
              logger.info(String.format("Bought %d for %.8f and sell it for %.8f, this is %.8f coins profit", tradeAmount, currentlyBoughtPrice, sellPrice, (1.0 * currentlyBoughtPrice - sellPrice) * tradeAmount));
              client.sell(tradeAmount, sellPrice);
            }
          } else {
            // WTF?!
            logger.error("DETECTED WTF!!!!!");
            logger.error("Order: " + order + " , Order-Status: " + status);
            client.panicSell(lastKnownTradingBalance, lastPrice);
            clear();
          }
        }
      } else {
        panicSellCounter++;
        logger.info(String.format("sell request not successful, increasing time %d\n", panicSellCounter));
        panicSellForCondition(lastPrice, lastKnownTradingBalance, panicSellCounter > 3);
      }
    } else {
      logger.warn("Order was canceled, cleaning up.");
      clear(); // Order was canceled, so clear and go on
    }
  }
} catch (Exception e) {
  logger.error("Unable to perform ticker", e);
}
trackingLastPrice = lastPrice;

}

private void panicSellForCondition(double lastPrice, double lastKnownTradingBalance, boolean condition) {
if (condition) {
logger.info("panicSellForCondition");
client.panicSell(lastKnownTradingBalance, lastPrice);
clear();
}
}

private void clear() {
panicBuyCounter = 0;
panicSellCounter = 0;
orderId = null;
currentlyBoughtPrice = null;
}

List getBalances() {
return client.getBalances();
}
}
TradingClient.java:package io.github.unterstein;

import com.binance.api.client.BinanceApiClientFactory;
import com.binance.api.client.BinanceApiRestClient;
import com.binance.api.client.domain.OrderSide;
import com.binance.api.client.domain.OrderType;
import com.binance.api.client.domain.TimeInForce;
import com.binance.api.client.domain.account.AssetBalance;
import com.binance.api.client.domain.account.NewOrder;
import com.binance.api.client.domain.account.NewOrderResponse;
import com.binance.api.client.domain.account.Order;
import com.binance.api.client.domain.account.request.CancelOrderRequest;
import com.binance.api.client.domain.account.request.OrderRequest;
import com.binance.api.client.domain.account.request.OrderStatusRequest;
import com.binance.api.client.domain.market.Candlestick;
import com.binance.api.client.domain.market.CandlestickInterval;
import com.binance.api.client.domain.market.OrderBook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public class TradingClient {
private static Logger logger = LoggerFactory.getLogger(TradingClient.class);

private BinanceApiRestClient client;
private String baseCurrency;
private String tradeCurrency;
private String symbol;

TradingClient(String baseCurrency, String tradeCurrency, String key, String secret) {
this.baseCurrency = baseCurrency;
this.tradeCurrency = tradeCurrency;
BinanceApiClientFactory factory = BinanceApiClientFactory.newInstance(key, secret);
client = factory.newRestClient();
symbol = tradeCurrency + baseCurrency;
}

// The bid price represents the maximum price that a buyer is willing to pay for a security.
// The ask price represents the minimum price that a seller is willing to receive.
public OrderBook getOrderBook() {
return client.getOrderBook(symbol, 5);
}

public AssetBalance getBaseBalance() {
return client.getAccount().getAssetBalance(baseCurrency);
}

public AssetBalance getTradingBalance() {
return client.getAccount().getAssetBalance(tradeCurrency);
}

public double assetBalanceToDouble(AssetBalance balance) {
return Double.valueOf(balance.getFree()) + Double.valueOf(balance.getLocked());
}

public double getAllTradingBalance() {
AssetBalance tradingBalance = getTradingBalance();
return assetBalanceToDouble(tradingBalance);
}

public boolean tradingBalanceAvailable(AssetBalance tradingBalance) {
return assetBalanceToDouble(tradingBalance) > 1;
}

public List getBalances() {
return client.getAccount().getBalances();
}

public List getOpenOrders() {
OrderRequest request = new OrderRequest(symbol);
return client.getOpenOrders(request);
}

public List getCandlestickBars() {
//OrderRequest request = new OrderRequest(symbol);
return client.getCandlestickBars("NEOETH", CandlestickInterval.WEEKLY);
}

public void cancelAllOrders() {
getOpenOrders().forEach(order -> client.cancelOrder(new CancelOrderRequest(symbol, order.getOrderId())));
}

// * GTC (Good-Til-Canceled) orders are effective until they are executed or canceled.
// * IOC (Immediate or Cancel) orders fills all or part of an order immediately and cancels the remaining part of the order.
public NewOrderResponse buy(int quantity, double price) {
String priceString = String.format("%.8f", price).replace(",", ".");
logger.info(String.format("Buying %d for %s\n", quantity, priceString));
NewOrder order = new NewOrder(symbol, OrderSide.BUY, OrderType.LIMIT, TimeInForce.GTC, "" + quantity, priceString);
return client.newOrder(order);
}

public void sell(int quantity, double price) {
String priceString = String.format("%.8f", price).replace(",", ".");
logger.info(String.format("Selling %d for %s\n", quantity, priceString));
NewOrder order = new NewOrder(symbol, OrderSide.SELL, OrderType.LIMIT, TimeInForce.GTC, "" + quantity, priceString);
client.newOrder(order);
}

public void sellMarket(int quantity) {
if (quantity > 0) {
logger.info("Selling to MARKET with quantity " + quantity);
NewOrder order = new NewOrder(symbol, OrderSide.SELL, OrderType.MARKET, null, "" + quantity);
client.newOrder(order);
} else {
logger.info("not executing - 0 quantity sell");
}
}

public Order getOrder(long orderId) {
return client.getOrderStatus(new OrderStatusRequest(symbol, orderId));
}

public double lastPrice() {
return Double.valueOf(client.get24HrPriceStatistics(symbol).getLastPrice());
}

public void cancelOrder(long orderId) {
logger.info("Cancelling order " + orderId);
client.cancelOrder(new CancelOrderRequest(symbol, orderId));
}

public void panicSell(double lastKnownAmount, double lastKnownPrice) {
logger.error("!!!! PANIC SELL !!!!");
logger.warn(String.format("Probably selling %.8f for %.8f", lastKnownAmount, lastKnownPrice));
cancelAllOrders();
sellMarket(Double.valueOf(getTradingBalance().getFree()).intValue());
}
}
`