Introduction

Trading cryptocurrency effectively requires access to real-time market data and the ability to execute trades with minimal latency. In this post, let’s document the Java-based trading client that connects to Kraken’s WebSocket API v2, handling both market data streams and trading operations, code here: https://github.com/tinghau/tingh-dev-kraken-ws

WebSockets

Traditional REST APIs require constant polling, creating unnecessary network traffic and introducing delays. WebSockets, by contrast, maintain persistent connections that allow:

  • Real-time price updates with millisecond precision
  • Immediate order book changes notification
  • Instant trade confirmations
  • Significantly reduced latency for order execution

This persistent connection is crucial for implementing algorithmic trading strategies that need to react to market movements immediately.

Overview

The Kraken WebSocket client consists of several key components:

  1. Client Connection Layer: Manages the WebSocket connections to Kraken’s public and authenticated endpoints
  2. Subscription Management: Uses builder patterns for clean, fluent API subscription requests
  3. Data Processing Pipeline: Parses incoming JSON messages into structured data objects
  4. Data Storage: Persists market data to CSV files for later analysis
  5. Event Listeners: Provides callbacks for real-time data processing
  6. Authentication Handling: Secures private endpoint access for trading operations

Implementation Details

Connection Management

The system maintains three client connections:

  • KrakenDataClient - Public market data
  • KrakenDataAuthClient - Authenticated market data and order management
  • KrakenUserClient - User-specific data like balances and executions
private static KrakenDataClient connectClient() throws URISyntaxException {
    URI serverUri = new URI("wss://ws.kraken.com/v2");
    KrakenDataClient client = new KrakenDataClient(serverUri, BASE_DIRECTORY);
    client.connect();
    return client;
}

Subscription Management

Each data type has its own subscription builder, creating a clean API for channel subscriptions:

private void subscribeToOhlc() {
    OhlcSubscriptionBuilder ohlcSubscription = new OhlcSubscriptionBuilder("BTC/USD");
    ohlcSubscription.interval(1); // 1-second interval
    dataClient.subscribeToOhlc(ohlcSubscription);
}

Authentication

For authenticated endpoints, there is supporting code to generate the authentication token.

public class AuthTokens {

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

    private static final String PUBLIC_KEY = "";
    private static final String PRIVATE_KEY = "";

    public String getToken() {
        // Generate a token using the PUBLIC_KEY and PRIVATE_KEY.
    }
}

Performance Considerations

Future improvements for performant data streams:

  1. Dedicated Threads: Use a dedicated thread for each data handler.
  2. RingBuffer: Read into a ring buffer (Disruptor or Agrona) for message handling
  3. Efficient Data Structures: Preferring primitive-based data structures.
  4. Batched File I/O: To reduce disk access frequency when saving market data

Trading Possibilities

With this infrastructure in place, it’s possible to implement various algorithmic strategies:

  • Technical indicator calculations on real-time OHLC data
  • Event-driven trading based on price movements
  • Order book analysis for liquidity detection

Next

This foundation provides numerous opportunities for expansion:

  • Machine learning models for price prediction
  • Backtesting framework using the collected CSV data
  • Integration with additional exchanges for cross-platform arbitrage

Kraken has made available its historical market data: https://support.kraken.com/hc/en-us/articles/360047543791-Downloadable-historical-market-data-time-and-sales-

Summary

Building a real-time trading client with Java and WebSockets creates a powerful foundation for algorithmic cryptocurrency trading. The architecture’s flexibility allows for rapid strategy development while the real-time nature of WebSockets ensures a market opportunity is never missed. This forms the basis for a potentially sophisticated trading system.