Algo-Trading Strategies in Cryptocurrency

When it comes to cryptocurrency trading, quantitative strategies are a widely discussed topic. By automating and systematizing the trading process, quantitative strategies help traders execute trades more efficiently and respond quickly to market fluctuations. In this article, we’ll explore high-frequency trading (HFT) strategies in the context of cryptocurrencies. HFT aims to profit through rapid trade execution and exploiting bid-ask spreads, making it one of the most notable strategies in the crypto space. We’ll introduce several common high-frequency trading strategies and provide code examples to help readers better understand and implement them.

1. Market Making Strategy

Market making is a type of HFT strategy that seeks to earn profits by providing liquidity. Market makers place both buy and sell orders simultaneously, facilitating market activity and profiting from the bid-ask spread. The core idea of market making is to act as a bridge in the market by quoting both sides and enabling transactions between buyers and sellers. Market makers frequently adjust order prices and volumes to maintain liquidity and maximize spread profits.

Key Characteristics:

• Fast Order Execution: Market makers must be able to quickly adjust order prices and volumes.
• High Automation: Market making strategies are usually highly automated, relying on computer algorithms for decision-making and execution.
• Profit from Spread: Market makers profit from the difference between buying and selling prices.

Implementation Steps:

1. Determine Market Prices: Monitor market data to obtain the latest bid and ask prices.
2. Define Pricing Strategy: Set bid and ask prices based on market conditions and strategy parameters.
3. Order Placement: Submit calculated prices and volumes to the market.
4. Monitoring and Adjustment: Continuously track market changes and adjust orders accordingly.

1.1 Market Making Java Code Example

import java.util.Random;

public class MarketMakerStrategy {
    private double buyPrice; 
    private double sellPrice; 
    private double spread; 
    private double midPrice; 
    private double minSpread; 
    private double maxSpread; 
    private double minQty; 
    private double maxQty; 
    private Random random;

    public MarketMakerStrategy(double initialBuyPrice, double initialSellPrice, double minSpread, double maxSpread, double minQty, double maxQty) {
        this.buyPrice = initialBuyPrice;
        this.sellPrice = initialSellPrice;
        this.minSpread = minSpread;
        this.maxSpread = maxSpread;
        this.minQty = minQty;
        this.maxQty = maxQty;
        this.random = new Random();
        updateMidPrice();
        updateSpread();
    }

    private void updateMidPrice() {
        midPrice = (buyPrice + sellPrice) / 2;
    }

    private void updateSpread() {
        spread = random.nextDouble() * (maxSpread - minSpread) + minSpread;
    }

    private double generateQty() {
        return random.nextDouble() * (maxQty - minQty) + minQty;
    }

    public void updateBuyPrice(double newBuyPrice) {
        buyPrice = newBuyPrice;
        updateMidPrice();
        updateSpread();
    }

    public void updateSellPrice(double newSellPrice) {
        sellPrice = newSellPrice;
        updateMidPrice();
        updateSpread();
    }

    public void generateBuyOrder() {
        double buyQty = generateQty();
        double buyOrderPrice = midPrice - spread / 2; // 在中间价上减去一半的价差作为买入价
        System.out.println("Generated Buy Order - Price: " + buyOrderPrice + ", Quantity: " + buyQty);
    }

    public void generateSellOrder() {
        double sellQty = generateQty();
        double sellOrderPrice = midPrice + spread / 2; // 在中间价上加上一半的价差作为卖出价
        System.out.println("Generated Sell Order - Price: " + sellOrderPrice + ", Quantity: " + sellQty);
    }

    public static void main(String[] args) {
        MarketMakerStrategy strategy = new MarketMakerStrategy(100, 102, 0.5, 1.5, 10, 50);

        for (int i = 0; i < 10; i++) {
            double newBuyPrice = strategy.buyPrice + (strategy.random.nextDouble() - 0.5) * 2;
            double newSellPrice = strategy.sellPrice + (strategy.random.nextDouble() - 0.5) * 2;
            strategy.updateBuyPrice(newBuyPrice);
            strategy.updateSellPrice(newSellPrice);
            strategy.generateBuyOrder();
            strategy.generateSellOrder();
        }
    }
}

1.2 Market Making Python Code Example

import random

class MarketMakerStrategy:
    def __init__(self, initial_buy_price, initial_sell_price, min_spread, max_spread, min_qty, max_qty):
        self.buy_price = initial_buy_price
        self.sell_price = initial_sell_price
        self.min_spread = min_spread
        self.max_spread = max_spread
        self.min_qty = min_qty
        self.max_qty = max_qty
        self.random = random.Random()
        self.mid_price = (self.buy_price + self.sell_price) / 2
        self.spread = self.random.uniform(self.min_spread, self.max_spread)

    def update_prices(self, new_buy_price, new_sell_price):
        self.buy_price = new_buy_price
        self.sell_price = new_sell_price
        self.mid_price = (self.buy_price + self.sell_price) / 2
        self.spread = self.random.uniform(self.min_spread, self.max_spread)

    def generate_buy_order(self):
        buy_qty = self.random.uniform(self.min_qty, self.max_qty)
        buy_order_price = self.mid_price - self.spread / 2
        print(f"Generated Buy Order - Price: {buy_order_price}, Quantity: {buy_qty}")

    def generate_sell_order(self):
        sell_qty = self.random.uniform(self.min_qty, self.max_qty)
        sell_order_price = self.mid_price + self.spread / 2
        print(f"Generated Sell Order - Price: {sell_order_price}, Quantity: {sell_qty}")

strategy = MarketMakerStrategy(100, 102, 0.5, 1.5, 10, 50)

for i in range(10):
    new_buy_price = strategy.buy_price + (strategy.random.random() - 0.5) * 2
    new_sell_price = strategy.sell_price + (strategy.random.random() - 0.5) * 2
    strategy.update_prices(new_buy_price, new_sell_price)
    strategy.generate_buy_order()
    strategy.generate_sell_order()

2. Arbitrage Trading

Arbitrage trading involves profiting from price differences between exchanges or trading pairs. In the crypto market, discrepancies often exist across different platforms, allowing traders to buy low on one exchange and sell high on another.

Implementation Steps:

1. Initialize Price Data: Simulate price data from two exchanges. In practice, real-time data can be fetched via exchange APIs and stored in a Map.
2. Compare Prices: Loop through each cryptocurrency and check for price differences between the two exchanges.
3. Calculate Arbitrage Opportunities: If a coin is priced lower on one exchange and higher on another, calculate the potential profit and report it.

Execution Process:

• Loop through Exchange A’s data and check if the same asset exists in Exchange B.
• If so, calculate the price difference (Exchange B’s price minus Exchange A’s).
• If the difference is positive, output the arbitrage opportunity, including coin name, prices on both exchanges, and potential profit.

2.1 Arbitrage Trading Java Code Example

import java.util.HashMap;
import java.util.Map;

public class ArbitrageTradingStrategy {
    private Map<String, Double> exchangeA; 
    private Map<String, Double> exchangeB; 

    public ArbitrageTradingStrategy() {
        this.exchangeA = new HashMap<>();
        this.exchangeB = new HashMap<>();
        exchangeA.put("BTC", 10000.0);
        exchangeA.put("ETH", 500.0);
        exchangeB.put("BTC", 10100.0);
        exchangeB.put("ETH", 510.0);
    }

    public void executeArbitrage() {
        for (String currency : exchangeA.keySet()) {
            if (exchangeB.containsKey(currency)) {
                double priceDifference = exchangeB.get(currency) - exchangeA.get(currency);
                if (priceDifference > 0) {
                    System.out.println("Arbitrage Opportunity: Buy " + currency + " on Exchange A, Sell on Exchange B. Profit: " + priceDifference);
                }
            }
        }
    }

    public static void main(String[] args) {
        ArbitrageTradingStrategy strategy = new ArbitrageTradingStrategy();
        strategy.executeArbitrage();
    }
}

2.2 Arbitrage Trading Python Code Example

import java.util.HashMap;
import java.util.Map;

public class ArbitrageTradingStrategy {
    private Map<String, Double> exchangeA;
    private Map<String, Double> exchangeB;

    public ArbitrageTradingStrategy() {
        this.exchangeA = new HashMap<>();
        this.exchangeB = new HashMap<>();
        exchangeA.put("BTC", 10000.0);
        exchangeA.put("ETH", 500.0);
        exchangeB.put("BTC", 10100.0);
        exchangeB.put("ETH", 510.0);
    }

    public void executeArbitrage() {
        for (String currency : exchangeA.keySet()) {
            if (exchangeB.containsKey(currency)) {
                double priceDifference = exchangeB.get(currency) - exchangeA.get(currency);
                if (priceDifference > 0) {
                    System.out.println("Arbitrage Opportunity: Buy " + currency + " on Exchange A, Sell on Exchange B. Profit: " + priceDifference);
                }
            }
        }
    }

    public static void main(String[] args) {
        ArbitrageTradingStrategy strategy = new ArbitrageTradingStrategy();
        strategy.executeArbitrage();
    }
}

In the ArbitrageTradingStrategy class, we initialize price data for both exchanges and use the execute_arbitrage method to check for arbitrage opportunities with positive profit margins.

3. Order Book Imbalance Tracking

Order Book Imbalance Tracking involves monitoring buy and sell orders and executing trades based on detected imbalances. For example, if buy orders significantly outweigh sell orders, it may suggest an upcoming price increase, prompting a buy.

3.1 Java Code Example

import java.util.Random;

public class OrderBookImbalanceTrackingStrategy {
    private double buyOrders;
    private double sellOrders;
    private double imbalanceThreshold;
    private Random random;

    public OrderBookImbalanceTrackingStrategy(double imbalanceThreshold) {
        this.imbalanceThreshold = imbalanceThreshold;
        this.random = new Random();
        this.buyOrders = random.nextDouble() * 100;
        this.sellOrders = random.nextDouble() * 100;
    }

    public void updateOrderBook() {
        this.buyOrders = random.nextDouble() * 100;
        this.sellOrders = random.nextDouble() * 100;
        checkImbalance();
    }

    private void checkImbalance() {
        if (buyOrders > sellOrders + imbalanceThreshold) {
            System.out.println("Imbalance detected: Buy orders significantly higher than sell orders. Execute buy trade.");
        } else if (sellOrders > buyOrders + imbalanceThreshold) {
            System.out.println("Imbalance detected: Sell orders significantly higher than buy orders. Execute sell trade.");
        } else {
            System.out.println("Order book is balanced. No trade execution needed.");
        }
    }

    public static void main(String[] args) {
        OrderBookImbalanceTrackingStrategy strategy = new OrderBookImbalanceTrackingStrategy(10);

        for (int i = 0; i < 5; i++) {
            strategy.updateOrderBook();
        }
    }
}

Implementation Steps:

1. Initialize Parameters: Set imbalance threshold in the constructor. This determines when the order book is considered imbalanced.
2. Simulate Order Book Updates: Use the updateOrderBook method to simulate order book updates (real-world data would typically come from exchange APIs or push feeds).
3. Check Imbalance: The checkImbalance method compares buy and sell volumes. If the buy volume is much higher, trigger a buy; if the reverse is true, trigger a sell.
4. Execute Trades: Based on the detected imbalance, execute the appropriate trade. In this simplified example, we just print messages instead of performing actual trades.
5. Repeat: Continuously monitor and update the order book, checking for imbalances in a main loop.

3.2 Python Code Example

import random

class OrderBookImbalanceTrackingStrategy:
    def __init__(self, imbalance_threshold):
        self.imbalance_threshold = imbalance_threshold
        self.random = random.Random()
        self.buy_orders = self.random.uniform(50, 100)
        self.sell_orders = self.random.uniform(50, 100) 


    def update_order_book(self):
        self.buy_orders = self.random.uniform(50, 100) 
        self.sell_orders = self.random.uniform(50, 100) 
        self.check_imbalance()

    def check_imbalance(self):
        if self.buy_orders > self.sell_orders + self.imbalance_threshold:
            print("Imbalance detected: Buy orders significantly higher than sell orders. Execute buy trade.")
        elif self.sell_orders > self.buy_orders + self.imbalance_threshold:
            print("Imbalance detected: Sell orders significantly higher than buy orders. Execute sell trade.")
        else:
            print("Order book is balanced. No trade execution needed.")

strategy = OrderBookImbalanceTrackingStrategy(10)  

for i in range(5):
    strategy.update_order_book()

4. Technical Indicator-Based Trading

This strategy uses technical indicators like Moving Averages (MA) and Relative Strength Index (RSI) to identify price patterns and make trading decisions. Rapid changes in these indicators can prompt quick trades.

Implementation Steps:

1. Prepare Price Data:
   Retrieve historical data (e.g., via Alltick API) and store it in an array for indicator calculations.
2. Calculate Moving Average:
   Use a sliding window to smooth the price data and identify trends, computing the average price at each time step.
3. Calculate RSI:
   RSI measures the speed and magnitude of price changes. It’s calculated based on gains and losses over a fixed window.
4. Define Trading Rules:
   Create buy/sell rules based on indicator values—e.g., moving average crossovers or RSI overbought/oversold conditions.
5. Execute Trades:
   Based on trading rules, perform buy/sell actions via API. Consider transaction costs, volumes, frequency, and risk management.
6. Monitoring and Adjustment:
   Continuously monitor market and trade execution. Adjust strategies based on results and market conditions.

4.1 Technical Indicator Java Code Example

public class TechnicalIndicatorTradingStrategy {
    private double[] priceData;
    private int windowSize; 
    private double[] movingAverage; 
    private double[] rsi;

    public TechnicalIndicatorTradingStrategy(double[] priceData, int windowSize) {
        this.priceData = priceData;
        this.windowSize = windowSize;
        this.movingAverage = calculateMovingAverage();
        this.rsi = calculateRSI();
    }

    private double[] calculateMovingAverage() {
        double[] ma = new double[priceData.length - windowSize + 1];
        for (int i = 0; i < ma.length; i++) {
            double sum = 0;
            for (int j = i; j < i + windowSize; j++) {
                sum += priceData[j];
            }
            ma[i] = sum / windowSize;
        }
        return ma;
    }

    private double[] calculateRSI() {
        double[] rsi = new double[priceData.length - windowSize + 1];
        double[] priceChange = new double[priceData.length - 1];
        for (int i = 0; i < priceChange.length; i++) {
            priceChange[i] = priceData[i + 1] - priceData[i];
        }
        for (int i = 0; i < rsi.length; i++) {
            double sumGain = 0, sumLoss = 0;
            for (int j = i; j < i + windowSize; j++) {
                if (priceChange[j] > 0) {
                    sumGain += priceChange[j];
                } else {
                    sumLoss -= priceChange[j];
                }
            }
            double avgGain = sumGain / windowSize;
            double avgLoss = sumLoss / windowSize;
            double rs = avgGain / avgLoss;
            rsi[i] = 100 - (100 / (1 + rs));
        }
        return rsi;
    }

    public void executeStrategy() {
    }

    public static void main(String[] args) {
        double[] priceData = {100, 105, 110, 115, 120, 115, 110, 105, 100};
        int windowSize = 3;

        TechnicalIndicatorTradingStrategy strategy = new TechnicalIndicatorTradingStrategy(priceData, windowSize);
        strategy.executeStrategy();
    }
}

4.2 Technical Indicator Python Code Example

import numpy as np

class TechnicalIndicatorTradingStrategy:
    def __init__(self, price_data, window_size):
        self.price_data = price_data
        self.window_size = window_size
        self.moving_average = self.calculate_moving_average()
        self.rsi = self.calculate_rsi()

    def calculate_moving_average(self):
        moving_average = np.convolve(self.price_data, np.ones(self.window_size) / self.window_size, mode='valid')
        return moving_average

    def calculate_rsi(self):
        deltas = np.diff(self.price_data)
        gain = deltas.copy()
        loss = deltas.copy()
        gain[gain < 0] = 0
        loss[loss > 0] = 0
        avg_gain = np.mean(gain[:self.window_size])
        avg_loss = -np.mean(loss[:self.window_size])
        rsi = np.zeros_like(self.price_data)
        rsi[:self.window_size] = 100. - 100. / (1. + avg_gain / avg_loss)
        for i in range(self.window_size, len(self.price_data)):
            delta = deltas[i - 1]  # price change
            gain_value = max(0, delta)
            loss_value = -min(0, delta)
            avg_gain = (avg_gain * (self.window_size - 1) + gain_value) / self.window_size
            avg_loss = (avg_loss * (self.window_size - 1) + loss_value) / self.window_size
            rs = avg_gain / avg_loss
            rsi[i] = 100. - 100. / (1. + rs)
        return rsi


    def execute_strategy(self):

        pass

price_data = np.array([100, 105, 110, 115, 120, 115, 110, 105, 100])
window_size = 3

strategy = TechnicalIndicatorTradingStrategy(price_data, window_size)
strategy.execute_strategy()