diff --git a/pom.xml b/pom.xml index 3d611ac..3662740 100644 --- a/pom.xml +++ b/pom.xml @@ -24,20 +24,14 @@ - com.xeiam.xchange + org.knowm.xchange xchange-core - 1.9.0 + 4.2.3 - com.xeiam.xchange + org.knowm.xchange xchange-bitstamp - 1.9.0 - - - - com.xeiam.xchart - xchart - 2.2.1 + 4.2.3 diff --git a/src/main/java/eu/verdelhan/bitraac/AlgorithmComparator.java b/src/main/java/eu/verdelhan/bitraac/AlgorithmComparator.java index 5a7f7da..e4114e4 100644 --- a/src/main/java/eu/verdelhan/bitraac/AlgorithmComparator.java +++ b/src/main/java/eu/verdelhan/bitraac/AlgorithmComparator.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.marketdata.Trade; +import java.math.BigDecimal; + +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.marketdata.Trade; + import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; import eu.verdelhan.bitraac.data.ExchangeAccount; import eu.verdelhan.bitraac.data.ExchangeMarket; -import java.math.BigDecimal; public class AlgorithmComparator { @@ -20,7 +22,7 @@ public void compare(TradingAlgorithm... algorithms) { for (TradingAlgorithm algorithm : algorithms) { processMarketOrder(algorithm, trade); } - btcUsd = trade.getPrice().getAmount(); + btcUsd = trade.getPrice(); } // Results @@ -45,12 +47,12 @@ private void processMarketOrder(TradingAlgorithm algorithm, Trade lastTrade) { if (order.getType() == Order.OrderType.BID) { // Buy if (account.isEnoughUsd(order, lastTrade)) { - account.buy(order.getTradableAmount(), lastTrade.getPrice()); + account.buy(order.getOriginalAmount(), lastTrade.getPrice()); } } else if (order.getType() == Order.OrderType.ASK) { // Sell if (account.isEnoughBtc(order)) { - account.sell(order.getTradableAmount(), lastTrade.getPrice()); + account.sell(order.getOriginalAmount(), lastTrade.getPrice()); } } } diff --git a/src/main/java/eu/verdelhan/bitraac/ComparativeChart.java b/src/main/java/eu/verdelhan/bitraac/ComparativeChart.java deleted file mode 100644 index 1b29a51..0000000 --- a/src/main/java/eu/verdelhan/bitraac/ComparativeChart.java +++ /dev/null @@ -1,27 +0,0 @@ -package eu.verdelhan.bitraac; - -import com.xeiam.xchange.dto.marketdata.Trade; -import com.xeiam.xchart.Chart; -import com.xeiam.xchart.SwingWrapper; -import java.util.ArrayList; -import java.util.Date; - -public class ComparativeChart { - - private static Chart CHART = new Chart(800, 600); - - public static void addTradeSeries(String seriesName, ArrayList trades) { - ArrayList dates = new ArrayList(); - ArrayList prices = new ArrayList(); - for (Trade trade : trades) { - dates.add(trade.getTimestamp()); - prices.add(trade.getPrice().getAmount()); - } - CHART.addDateSeries(seriesName, dates, prices); - } - - public static void show() { - new SwingWrapper(CHART).displayChart(); - } - -} diff --git a/src/main/java/eu/verdelhan/bitraac/algorithms/TradingAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/algorithms/TradingAlgorithm.java index 27f774b..c8fc39d 100644 --- a/src/main/java/eu/verdelhan/bitraac/algorithms/TradingAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/algorithms/TradingAlgorithm.java @@ -1,6 +1,7 @@ package eu.verdelhan.bitraac.algorithms; -import com.xeiam.xchange.dto.Order; +import org.knowm.xchange.dto.Order; + import eu.verdelhan.bitraac.data.ExchangeAccount; public abstract class TradingAlgorithm { diff --git a/src/main/java/eu/verdelhan/bitraac/data/ExchangeAccount.java b/src/main/java/eu/verdelhan/bitraac/data/ExchangeAccount.java index ef51466..7867edf 100644 --- a/src/main/java/eu/verdelhan/bitraac/data/ExchangeAccount.java +++ b/src/main/java/eu/verdelhan/bitraac/data/ExchangeAccount.java @@ -1,10 +1,10 @@ package eu.verdelhan.bitraac.data; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.marketdata.Trade; import java.math.BigDecimal; import java.math.RoundingMode; -import org.joda.money.BigMoney; + +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.marketdata.Trade; /** * An exchange account. @@ -61,7 +61,7 @@ public BigDecimal getCurrentBtcBalance() { */ public boolean isEnoughUsd(Order order, Trade lastTrade) { if (order.getType() == Order.OrderType.BID) { - return (order.getTradableAmount().multiply(lastTrade.getPrice().getAmount()).compareTo(currentUsdBalance) <= 0); + return (order.getOriginalAmount().multiply(lastTrade.getPrice()).compareTo(currentUsdBalance) <= 0); } return true; } @@ -72,7 +72,7 @@ public boolean isEnoughUsd(Order order, Trade lastTrade) { */ public boolean isEnoughBtc(Order order) { if (order.getType() == Order.OrderType.ASK) { - return (order.getTradableAmount().compareTo(currentBtcBalance) <= 0); + return (order.getOriginalAmount().compareTo(currentBtcBalance) <= 0); } return true; } @@ -83,11 +83,11 @@ public boolean isEnoughBtc(Order order) { * @param amount the amount of BTC to buy * @param price the unit price */ - public void buy(BigDecimal amount, BigMoney price) { + public void buy(BigDecimal amount, BigDecimal price) { // Deducting transaction fee - BigDecimal usdAmount = deductFee(amount.multiply(price.getAmount())); + BigDecimal usdAmount = deductFee(amount.multiply(price)); currentUsdBalance = currentUsdBalance.subtract(usdAmount); - currentBtcBalance = currentBtcBalance.add(usdAmount.divide(price.getAmount(), RoundingMode.HALF_UP)); + currentBtcBalance = currentBtcBalance.add(usdAmount.divide(price, RoundingMode.HALF_UP)); // Updating the trade counter tradeCounter++; } @@ -98,10 +98,10 @@ public void buy(BigDecimal amount, BigMoney price) { * @param amount the amount of BTC to sell * @param price the unit price */ - public void sell(BigDecimal amount, BigMoney price) { + public void sell(BigDecimal amount, BigDecimal price) { currentBtcBalance = currentBtcBalance.subtract(amount); // Deducting transaction fee - BigDecimal usdAmount = deductFee(amount.multiply(price.getAmount())); + BigDecimal usdAmount = deductFee(amount.multiply(price)); currentUsdBalance = currentUsdBalance.add(usdAmount); // Updating the trade counter tradeCounter++; diff --git a/src/main/java/eu/verdelhan/bitraac/data/ExchangeMarket.java b/src/main/java/eu/verdelhan/bitraac/data/ExchangeMarket.java index 14885f1..9a154c5 100644 --- a/src/main/java/eu/verdelhan/bitraac/data/ExchangeMarket.java +++ b/src/main/java/eu/verdelhan/bitraac/data/ExchangeMarket.java @@ -1,14 +1,5 @@ package eu.verdelhan.bitraac.data; -import au.com.bytecode.opencsv.CSVReader; -import com.xeiam.xchange.Exchange; -import com.xeiam.xchange.ExchangeFactory; -import com.xeiam.xchange.bitstamp.BitstampExchange; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.marketdata.Trade; -import com.xeiam.xchange.dto.marketdata.Trades; -import com.xeiam.xchange.service.polling.PollingMarketDataService; -import eu.verdelhan.bitraac.AlgorithmComparator; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; @@ -18,8 +9,17 @@ import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; -import org.joda.money.BigMoney; -import org.joda.money.CurrencyUnit; + +import org.knowm.xchange.Exchange; +import org.knowm.xchange.ExchangeFactory; +import org.knowm.xchange.bitstamp.BitstampExchange; +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.marketdata.Trade; +import org.knowm.xchange.dto.marketdata.Trades; +import org.knowm.xchange.service.marketdata.MarketDataService; + +import au.com.bytecode.opencsv.CSVReader; +import eu.verdelhan.bitraac.AlgorithmComparator; /** * An exchange market (e.g. Bitstamp, Mt.Gox, BTC-e, etc.) @@ -27,7 +27,7 @@ public class ExchangeMarket { private static final Exchange EXCHANGE = ExchangeFactory.INSTANCE.createExchange(BitstampExchange.class.getName()); - private static PollingMarketDataService marketDataService = EXCHANGE.getPollingMarketDataService(); + private static MarketDataService marketDataService = EXCHANGE.getMarketDataService(); /** The transaction fee ratio (e.g. 0.002 for 0.2%) */ private static final double TRANSACTION_FEE = 0.002; @@ -106,7 +106,7 @@ public static ArrayList getPreviousTrades() { public static void dumpBitstampData() { try { - Trades trades = marketDataService.getTrades(Currencies.BTC, Currencies.USD); + Trades trades = marketDataService.getTrades(CurrencyPair.BTC_USD); for (Trade t : trades.getTrades()) { System.out.println(t); } @@ -129,11 +129,12 @@ private static ArrayList getLocalTrades() { String[] line; while ((line = csvReader.readNext()) != null) { Date timestamp = new Date(Long.parseLong(line[0]) * 1000); - BigMoney price = BigMoney.of(CurrencyUnit.USD, new BigDecimal(line[1])); + BigDecimal price = new BigDecimal(line[1]); BigDecimal tradableAmount = new BigDecimal(line[2]); - Trade trade = new Trade(null, tradableAmount, Currencies.BTC, Currencies.USD, price, timestamp, 0); + Trade trade = new Trade(null, tradableAmount, CurrencyPair.BTC_USD, price, timestamp, "0"); trades.add(trade); } + csvReader.close(); } catch (IOException ioe) { Logger.getLogger(AlgorithmComparator.class.getName()).log(Level.SEVERE, "Unable to load trades from CSV", ioe); } diff --git a/src/main/java/eu/verdelhan/bitraac/data/Period.java b/src/main/java/eu/verdelhan/bitraac/data/Period.java index 713823b..7749817 100644 --- a/src/main/java/eu/verdelhan/bitraac/data/Period.java +++ b/src/main/java/eu/verdelhan/bitraac/data/Period.java @@ -1,11 +1,12 @@ package eu.verdelhan.bitraac.data; -import com.xeiam.xchange.dto.marketdata.Trade; +import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.Date; import java.util.concurrent.TimeUnit; -import org.joda.money.BigMoney; + +import org.knowm.xchange.dto.marketdata.Trade; /** * A period of time. @@ -82,7 +83,7 @@ public Trade getHigh() { Trade highTrade = null; if (trades != null) { for (Trade trade : trades) { - if (highTrade == null || highTrade.getPrice().isLessThan(trade.getPrice())) { + if (highTrade == null || highTrade.getPrice().compareTo(trade.getPrice())==-1) { highTrade = trade; } } @@ -97,7 +98,7 @@ public Trade getLow() { Trade lowTrade = null; if (trades != null) { for (Trade trade : trades) { - if (lowTrade == null || lowTrade.getPrice().isGreaterThan(trade.getPrice())) { + if (lowTrade == null || lowTrade.getPrice().compareTo(trade.getPrice())==1) { lowTrade = trade; } } @@ -117,11 +118,11 @@ public Trade getLast() { * (H + L + C) / 3 * @return the typical price */ - public BigMoney getTypicalPrice() { - BigMoney high = getHigh().getPrice(); - BigMoney low = getLow().getPrice(); - BigMoney close = getLast().getPrice(); - return high.plus(low).plus(close).dividedBy(3, RoundingMode.HALF_UP); + public BigDecimal getTypicalPrice() { + BigDecimal high = getHigh().getPrice(); + BigDecimal low = getLow().getPrice(); + BigDecimal close = getLast().getPrice(); + return high.add(low).add(close).divide(new BigDecimal(3), RoundingMode.HALF_UP); } @Override diff --git a/src/main/java/eu/verdelhan/bitraac/example/BinaryAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/example/BinaryAlgorithm.java index a8a7a62..8803427 100644 --- a/src/main/java/eu/verdelhan/bitraac/example/BinaryAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/example/BinaryAlgorithm.java @@ -1,15 +1,17 @@ package eu.verdelhan.bitraac.example; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.marketdata.Trade; -import com.xeiam.xchange.dto.trade.MarketOrder; -import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; -import eu.verdelhan.bitraac.data.ExchangeMarket; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.List; +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.marketdata.Trade; +import org.knowm.xchange.dto.trade.MarketOrder; + +import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; +import eu.verdelhan.bitraac.data.ExchangeMarket; + public class BinaryAlgorithm extends TradingAlgorithm { public BinaryAlgorithm(double initialUsdBalance, double initialBtcBalance) { @@ -22,16 +24,16 @@ public Order placeOrder() { double trendCoef = getTrendCoef(); if (trendCoef > 1.04) { // Up trend - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2.2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2.2), CurrencyPair.BTC_USD); } else if (trendCoef > 1.015) { // Up trend - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), CurrencyPair.BTC_USD); } else if (trendCoef < 0.99) { // Down trend - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), CurrencyPair.BTC_USD); } else if (trendCoef < 0.97) { // Down trend - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2.2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2.2), CurrencyPair.BTC_USD); } else { // Stability order = null; @@ -43,8 +45,8 @@ private double getTrendCoef() { double trendCoef = 1.0; if (ExchangeMarket.isEnoughTrades(2)) { List trades = ExchangeMarket.getPreviousTrades(); - BigDecimal previousPrice = trades.get(trades.size() - 2).getPrice().getAmount(); - BigDecimal lastPrice = trades.get(trades.size() - 1).getPrice().getAmount(); + BigDecimal previousPrice = trades.get(trades.size() - 2).getPrice(); + BigDecimal lastPrice = trades.get(trades.size() - 1).getPrice(); trendCoef = previousPrice.divide(lastPrice, 12, RoundingMode.HALF_UP).doubleValue(); } return trendCoef; diff --git a/src/main/java/eu/verdelhan/bitraac/example/MultiIndicatorsAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/example/MultiIndicatorsAlgorithm.java index a3f49f0..e1133a5 100644 --- a/src/main/java/eu/verdelhan/bitraac/example/MultiIndicatorsAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/example/MultiIndicatorsAlgorithm.java @@ -1,16 +1,18 @@ package eu.verdelhan.bitraac.example; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.trade.MarketOrder; +import java.math.BigDecimal; +import java.math.RoundingMode; + +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.trade.MarketOrder; + import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; import eu.verdelhan.bitraac.data.ExchangeMarket; import eu.verdelhan.bitraac.indicators.AroonDown; import eu.verdelhan.bitraac.indicators.AroonUp; import eu.verdelhan.bitraac.indicators.PPO; import eu.verdelhan.bitraac.indicators.ROC; -import java.math.BigDecimal; -import java.math.RoundingMode; public class MultiIndicatorsAlgorithm extends TradingAlgorithm { @@ -35,29 +37,29 @@ public Order placeOrder() { BigDecimal btcBalance = getExchangeAccount().getCurrentBtcBalance(); btcBalance = btcBalance.subtract(TRADE_MARGIN); if (btcBalance.compareTo(BigDecimal.ZERO) == 1) { - order = new MarketOrder(Order.OrderType.ASK, btcBalance, Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, btcBalance, CurrencyPair.BTC_USD); } } else if (isOversold()) { // Oversold - BigDecimal lastTradePrice = ExchangeMarket.getPreviousTrades().get(ExchangeMarket.getPreviousTrades().size() - 1).getPrice().getAmount(); + BigDecimal lastTradePrice = ExchangeMarket.getPreviousTrades().get(ExchangeMarket.getPreviousTrades().size() - 1).getPrice(); BigDecimal btcToBeBought = getExchangeAccount().getCurrentUsdBalance().divide(lastTradePrice, RoundingMode.HALF_UP).subtract(TRADE_MARGIN); if (btcToBeBought.compareTo(BigDecimal.ZERO) == 1) { - order = new MarketOrder(Order.OrderType.BID, btcToBeBought, Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, btcToBeBought, CurrencyPair.BTC_USD); } } else { double ppo = getTrendStrength(); if (ppo > 0.5) { // Strong up trend - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), CurrencyPair.BTC_USD); } else if (ppo > 0.1) { // Up trend - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(0.5), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(0.5), CurrencyPair.BTC_USD); } else if (ppo < -0.1) { // Down trend - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(0.5), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(0.5), CurrencyPair.BTC_USD); } else if (ppo < -0.4) { // Strong down trend - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), CurrencyPair.BTC_USD); } else { // Stability order = null; diff --git a/src/main/java/eu/verdelhan/bitraac/example/NoAlgorithmAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/example/NoAlgorithmAlgorithm.java index 1891067..4fd26d8 100644 --- a/src/main/java/eu/verdelhan/bitraac/example/NoAlgorithmAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/example/NoAlgorithmAlgorithm.java @@ -1,14 +1,16 @@ package eu.verdelhan.bitraac.example; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.marketdata.Trade; -import com.xeiam.xchange.dto.trade.MarketOrder; -import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; -import eu.verdelhan.bitraac.data.ExchangeMarket; import java.math.BigDecimal; import java.util.List; +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.marketdata.Trade; +import org.knowm.xchange.dto.trade.MarketOrder; + +import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; +import eu.verdelhan.bitraac.data.ExchangeMarket; + public class NoAlgorithmAlgorithm extends TradingAlgorithm { public NoAlgorithmAlgorithm(double initialUsdBalance, double initialBtcBalance) { @@ -21,8 +23,8 @@ public Order placeOrder() { if (ExchangeMarket.isEnoughTrades(1)) { List pastTrades = ExchangeMarket.getPreviousTrades(); Trade lastTrade = pastTrades.get(pastTrades.size() - 1); - BigDecimal nbBtcToBuy = new BigDecimal(1000.0 / lastTrade.getPrice().getAmount().doubleValue()); - order = new MarketOrder(Order.OrderType.BID, nbBtcToBuy, Currencies.BTC, Currencies.USD); + BigDecimal nbBtcToBuy = new BigDecimal(1000.0 / lastTrade.getPrice().doubleValue()); + order = new MarketOrder(Order.OrderType.BID, nbBtcToBuy, CurrencyPair.BTC_USD); } return order; } diff --git a/src/main/java/eu/verdelhan/bitraac/example/PPOAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/example/PPOAlgorithm.java index 24ae118..35ded05 100644 --- a/src/main/java/eu/verdelhan/bitraac/example/PPOAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/example/PPOAlgorithm.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.example; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.trade.MarketOrder; +import java.math.BigDecimal; + +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.trade.MarketOrder; + import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; import eu.verdelhan.bitraac.data.ExchangeMarket; import eu.verdelhan.bitraac.indicators.PPO; -import java.math.BigDecimal; public class PPOAlgorithm extends TradingAlgorithm { @@ -19,9 +21,9 @@ public Order placeOrder() { Order order; double ppo = getPPO(); if (ppo > 0.05) { - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), CurrencyPair.BTC_USD); } else if (ppo < -0.03) { - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), CurrencyPair.BTC_USD); } else { // Stability order = null; diff --git a/src/main/java/eu/verdelhan/bitraac/example/SimpleMovingAveragesAlgorithm.java b/src/main/java/eu/verdelhan/bitraac/example/SimpleMovingAveragesAlgorithm.java index cb89fe5..ee1d575 100644 --- a/src/main/java/eu/verdelhan/bitraac/example/SimpleMovingAveragesAlgorithm.java +++ b/src/main/java/eu/verdelhan/bitraac/example/SimpleMovingAveragesAlgorithm.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.example; -import com.xeiam.xchange.currency.Currencies; -import com.xeiam.xchange.dto.Order; -import com.xeiam.xchange.dto.trade.MarketOrder; +import java.math.BigDecimal; + +import org.knowm.xchange.currency.CurrencyPair; +import org.knowm.xchange.dto.Order; +import org.knowm.xchange.dto.trade.MarketOrder; + import eu.verdelhan.bitraac.algorithms.TradingAlgorithm; import eu.verdelhan.bitraac.data.ExchangeMarket; import eu.verdelhan.bitraac.indicators.SMA; -import java.math.BigDecimal; public class SimpleMovingAveragesAlgorithm extends TradingAlgorithm { @@ -20,10 +22,10 @@ public Order placeOrder() { double trendCoef = getTrendCoef(); if (trendCoef > 1.02) { // Up trend - order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.ASK, new BigDecimal(2), CurrencyPair.BTC_USD); } else if (trendCoef < 0.98) { // Down trend - order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), Currencies.BTC, Currencies.USD); + order = new MarketOrder(Order.OrderType.BID, new BigDecimal(2), CurrencyPair.BTC_USD); } else { // Stability order = null; diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/ADL.java b/src/main/java/eu/verdelhan/bitraac/indicators/ADL.java index 35c38db..92b4fb5 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/ADL.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/ADL.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * Accumulation distribution line (ADL) indicator. */ @@ -36,9 +38,9 @@ public BigDecimal execute() { for (Period period : periods) { // Getting high, low and close prices - BigDecimal highPrice = period.getHigh().getPrice().getAmount(); - BigDecimal lowPrice = period.getLow().getPrice().getAmount(); - BigDecimal closePrice = period.getLast().getPrice().getAmount(); + BigDecimal highPrice = period.getHigh().getPrice(); + BigDecimal lowPrice = period.getLow().getPrice(); + BigDecimal closePrice = period.getLast().getPrice(); // Calculating the money flow multiplier BigDecimal moneyFlowMultiplier = closePrice.subtract(lowPrice).subtract(highPrice.subtract(closePrice)).divide(highPrice.subtract(lowPrice), RoundingMode.HALF_UP); diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/AroonDown.java b/src/main/java/eu/verdelhan/bitraac/indicators/AroonDown.java index 5680ffd..bce5d04 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/AroonDown.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/AroonDown.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import com.xeiam.xchange.dto.marketdata.Trade; -import eu.verdelhan.bitraac.data.Period; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; -import org.joda.money.BigMoney; +import org.knowm.xchange.dto.marketdata.Trade; + +import eu.verdelhan.bitraac.data.Period; /** * Aroon down indicator. @@ -41,9 +43,9 @@ public Double execute() { if (lowPeriod == null) { lowPeriod = period; } else { - BigMoney lowPrice = lowPeriod.getLow().getPrice(); - if (currentLowTrade.getPrice().isLessThan(lowPrice) - || currentLowTrade.getPrice().isEqual(lowPrice)) { + BigDecimal lowPrice = lowPeriod.getLow().getPrice(); + if (currentLowTrade.getPrice().compareTo(lowPrice)==-1 + || currentLowTrade.getPrice().equals(lowPrice)) { // New low price lowPeriod = period; nbPeriodsSinceLow = 0; diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/AroonUp.java b/src/main/java/eu/verdelhan/bitraac/indicators/AroonUp.java index a90f979..ebb9f04 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/AroonUp.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/AroonUp.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import com.xeiam.xchange.dto.marketdata.Trade; -import eu.verdelhan.bitraac.data.Period; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; -import org.joda.money.BigMoney; +import org.knowm.xchange.dto.marketdata.Trade; + +import eu.verdelhan.bitraac.data.Period; /** * Aroon up indicator. @@ -41,9 +43,9 @@ public Double execute() { if (highPeriod == null) { highPeriod = period; } else { - BigMoney highPrice = highPeriod.getHigh().getPrice(); - if (currentHighTrade.getPrice().isGreaterThan(highPrice) - || currentHighTrade.getPrice().isEqual(highPrice)) { + BigDecimal highPrice = highPeriod.getHigh().getPrice(); + if (currentHighTrade.getPrice().compareTo(highPrice)==1 + || currentHighTrade.getPrice().equals(highPrice)) { // New high price highPeriod = period; nbPeriodsSinceHigh = 0; diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/EMA.java b/src/main/java/eu/verdelhan/bitraac/indicators/EMA.java index bdf1b9b..c17dc3c 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/EMA.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/EMA.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import com.xeiam.xchange.dto.marketdata.Trade; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import org.knowm.xchange.dto.marketdata.Trade; + +import eu.verdelhan.bitraac.data.Period; /** * Exponential moving average (EMA) indicator. @@ -28,7 +30,7 @@ public EMA(final List periods, int lastPeriods) { } this.periods = new ArrayList(periods.subList(nbPeriods - lastPeriods, nbPeriods)); // Weighting multiplier - multiplier = new BigDecimal((double) (2 / ((double) this.periods.size() + 1))); + multiplier = new BigDecimal(2 / ((double) this.periods.size() + 1)); } /** @@ -47,7 +49,7 @@ public BigDecimal execute() { for (int i = 11; i < nbPeriods; i++) { Trade periodLastTrade = periods.get(i).getLast(); if (periodLastTrade != null) { - BigDecimal closePrice = periodLastTrade.getPrice().getAmount(); + BigDecimal closePrice = periodLastTrade.getPrice(); ema = closePrice.subtract(ema).multiply(multiplier).add(ema); } } diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/MACD.java b/src/main/java/eu/verdelhan/bitraac/indicators/MACD.java index d4680b3..4481872 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/MACD.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/MACD.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * Moving average convergence divergence (MACD) indicator. */ diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/PPO.java b/src/main/java/eu/verdelhan/bitraac/indicators/PPO.java index f3c8d16..df51bde 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/PPO.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/PPO.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * Percentage price oscillator (PPO) indicator. */ diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/ROC.java b/src/main/java/eu/verdelhan/bitraac/indicators/ROC.java index 6a5ae1b..3f2f514 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/ROC.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/ROC.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * Rate of change (ROC) indicator. * Aka. Momentum @@ -35,8 +37,8 @@ public ROC(final List periods, int n) { @Override public Double execute() { try { - BigDecimal nPeriodsAgoClosePrice = periods.get(0).getLast().getPrice().getAmount(); - BigDecimal currentClosePrice = periods.get(periods.size() - 1).getLast().getPrice().getAmount(); + BigDecimal nPeriodsAgoClosePrice = periods.get(0).getLast().getPrice(); + BigDecimal currentClosePrice = periods.get(periods.size() - 1).getLast().getPrice(); return currentClosePrice.subtract(nPeriodsAgoClosePrice).divide(nPeriodsAgoClosePrice, RoundingMode.HALF_UP).multiply(IndicatorUtils.HUNDRED).doubleValue(); } catch (RuntimeException re) { diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/RSI.java b/src/main/java/eu/verdelhan/bitraac/indicators/RSI.java index 540b23a..2d3222d 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/RSI.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/RSI.java @@ -1,12 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; -import org.joda.money.BigMoney; + +import eu.verdelhan.bitraac.data.Period; /** * Relative strength index (RSI) indicator. @@ -43,17 +44,17 @@ public BigDecimal execute() { for (int i = 1; i < nbPeriods; i++) { Period previousPeriod = periods.get(i - 1); Period currentPeriod = periods.get(i); - BigMoney previousClosePrice = previousPeriod.getLast().getPrice(); - BigMoney currentClosePrice = currentPeriod.getLast().getPrice(); + BigDecimal previousClosePrice = previousPeriod.getLast().getPrice(); + BigDecimal currentClosePrice = currentPeriod.getLast().getPrice(); - if (previousClosePrice.isLessThan(currentClosePrice)) { + if (previousClosePrice.compareTo(currentClosePrice)==-1) { // Gain - gains.add(currentClosePrice.getAmount().subtract(previousClosePrice.getAmount())); + gains.add(currentClosePrice.subtract(previousClosePrice)); losses.add(BigDecimal.ZERO); - } else if (previousClosePrice.isGreaterThan(currentClosePrice)) { + } else if (previousClosePrice.compareTo(currentClosePrice)==1) { // Loss gains.add(BigDecimal.ZERO); - losses.add(previousClosePrice.getAmount().subtract(currentClosePrice.getAmount())); + losses.add(previousClosePrice.subtract(currentClosePrice)); } else { // Neither gain nor loss gains.add(BigDecimal.ZERO); diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/SMA.java b/src/main/java/eu/verdelhan/bitraac/indicators/SMA.java index 6bbc15e..25ab2ff 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/SMA.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/SMA.java @@ -1,12 +1,14 @@ package eu.verdelhan.bitraac.indicators; -import com.xeiam.xchange.dto.marketdata.Trade; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import org.knowm.xchange.dto.marketdata.Trade; + +import eu.verdelhan.bitraac.data.Period; /** * Simple moving average (SMA) indicator. @@ -41,7 +43,7 @@ public BigDecimal execute() { // No trade in the period nbPeriods--; } else { - average = average.add(periodLastTrade.getPrice().getAmount()); + average = average.add(periodLastTrade.getPrice()); } } return average.divide(new BigDecimal(nbPeriods), RoundingMode.HALF_UP); diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/StandardDeviation.java b/src/main/java/eu/verdelhan/bitraac/indicators/StandardDeviation.java index 202b7eb..c1695e4 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/StandardDeviation.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/StandardDeviation.java @@ -1,11 +1,13 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * Standard deviation indicator. */ @@ -37,7 +39,7 @@ public Double execute() { double sumOfSquaredDeviations = 0; for (Period period : periods) { - BigDecimal closePrice = period.getLast().getPrice().getAmount(); + BigDecimal closePrice = period.getLast().getPrice(); sumOfSquaredDeviations += closePrice.subtract(averageClosePrice).pow(2).doubleValue(); } diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/TrueRange.java b/src/main/java/eu/verdelhan/bitraac/indicators/TrueRange.java index 952b0cf..2f4463c 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/TrueRange.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/TrueRange.java @@ -1,9 +1,11 @@ package eu.verdelhan.bitraac.indicators; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; + import org.apache.commons.lang3.Validate; +import eu.verdelhan.bitraac.data.Period; + /** * True range indicator. */ @@ -35,8 +37,8 @@ public TrueRange(Period previousPeriod, Period currentPeriod) { @Override public Double execute() { // Current extrema prices - BigDecimal currentHighPrice = currentPeriod.getHigh().getPrice().getAmount(); - BigDecimal currentLowPrice = currentPeriod.getLow().getPrice().getAmount(); + BigDecimal currentHighPrice = currentPeriod.getHigh().getPrice(); + BigDecimal currentLowPrice = currentPeriod.getLow().getPrice(); double trueRange; if (previousPeriod == null) { @@ -44,7 +46,7 @@ public Double execute() { trueRange = currentHighPrice.subtract(currentLowPrice).doubleValue(); } else { // Using the previous close price - BigDecimal previousClosePrice = previousPeriod.getLast().getPrice().getAmount(); + BigDecimal previousClosePrice = previousPeriod.getLast().getPrice(); BigDecimal trueRangeMethod1 = currentHighPrice.subtract(currentLowPrice); BigDecimal trueRangeMethod2 = currentHighPrice.subtract(previousClosePrice).abs(); BigDecimal trueRangeMethod3 = currentLowPrice.subtract(previousClosePrice).abs(); diff --git a/src/main/java/eu/verdelhan/bitraac/indicators/Volume.java b/src/main/java/eu/verdelhan/bitraac/indicators/Volume.java index 538de09..45a7bed 100644 --- a/src/main/java/eu/verdelhan/bitraac/indicators/Volume.java +++ b/src/main/java/eu/verdelhan/bitraac/indicators/Volume.java @@ -1,9 +1,11 @@ package eu.verdelhan.bitraac.indicators; -import com.xeiam.xchange.dto.marketdata.Trade; -import eu.verdelhan.bitraac.data.Period; import java.math.BigDecimal; + import org.apache.commons.lang3.Validate; +import org.knowm.xchange.dto.marketdata.Trade; + +import eu.verdelhan.bitraac.data.Period; /** * Volume indicator. @@ -27,7 +29,7 @@ public Volume(Period period) { public BigDecimal execute() { BigDecimal volume = BigDecimal.ZERO; for (Trade trade : period.getTrades()) { - volume = volume.add(trade.getTradableAmount().multiply(trade.getPrice().getAmount())); + volume = volume.add(trade.getTradableAmount().multiply(trade.getPrice())); } return volume; }