Cryptocurrency Exchange API

Open Source Project

GitHubAPI Docs
Node.js
Express
PostgreSQL
Redis
WebSocket
Docker
Kubernetes

Project Overview

A high-performance, enterprise-grade REST API for cryptocurrency trading operations. Built with Node.js and designed to handle thousands of concurrent users with sub-millisecond response times. Features real-time WebSocket connections, advanced order matching, and comprehensive trading functionality.

The API supports spot trading, margin trading, futures contracts, and advanced order types. It includes robust security measures, rate limiting, and comprehensive monitoring. The system is designed for horizontal scaling and can handle millions of orders per day.

System Architecture

Microservices Architecture


┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Load Balancer │    │   API Gateway   │    │   Auth Service  │
│                 │    │                 │    │                 │
│  • Nginx        │◄──►│  • Rate Limiting│◄──►│  • JWT Tokens   │
│  • SSL Term.    │    │  • Routing      │    │  • 2FA          │
│  • Health Check │    │  • Validation   │    │  • Permissions  │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                        │                        │
         ▼                        ▼                        ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Trading Engine │    │  Market Data    │    │  User Service   │
│                 │    │                 │    │  • Profiles     │
│  • Order Match  │    │  • Price Feeds  │    │  • KYC/AML      │
│  • Risk Mgmt    │    │  • Candlesticks │    │  • Wallets      │
│  • Settlement   │    │  • Order Books  │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                        │                        │
         ▼                        ▼                        ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   PostgreSQL    │    │     Redis       │    │   Message Queue │
│                 │    │                 │    │                 │
│  • Orders       │    │  • Sessions     │    │  • RabbitMQ     │
│  • Trades       │    │  • Cache        │    │  • Event Stream │
│  • Balances     │    │  • Rate Limits  │    │  • Notifications│
└─────────────────┘    └─────────────────┘    └─────────────────┘

Core Services

  • • Trading Engine: Order matching and execution
  • • Market Data: Real-time price feeds and charts
  • • User Service: Account management and KYC
  • • Wallet Service: Cryptocurrency deposits/withdrawals

Infrastructure

  • • Kubernetes: Container orchestration
  • • Docker: Containerized services
  • • Prometheus: Metrics and monitoring
  • • Grafana: Dashboards and alerting

Data Layer

  • • PostgreSQL: Primary database with replication
  • • Redis: Caching and session storage
  • • InfluxDB: Time-series market data
  • • Elasticsearch: Logging and search

API Endpoints

Trading Endpoints

POST/api/v1/orders
Place new order
GET/api/v1/orders
Get user orders
DELETE/api/v1/orders/:id
Cancel order

Market Data Endpoints

GET/api/v1/ticker/:symbol
24hr ticker statistics
GET/api/v1/orderbook/:symbol
Order book depth
GET/api/v1/klines/:symbol
Candlestick data

Performance Metrics

<1ms
Average Response Time
10K+
Requests/Second
99.99%
Uptime SLA
1M+
Orders/Day

Code Examples

Order Matching Engine

class OrderMatchingEngine {
  constructor() {
    this.buyOrders = new PriorityQueue((a, b) => b.price - a.price);
    this.sellOrders = new PriorityQueue((a, b) => a.price - b.price);
  }

  async processOrder(order) {
    const oppositeBook = order.side === 'buy' ? this.sellOrders : this.buyOrders;
    const matches = [];

    while (!oppositeBook.isEmpty() && order.quantity > 0) {
      const topOrder = oppositeBook.peek();
      
      if (!this.canMatch(order, topOrder)) break;
      
      const matchQuantity = Math.min(order.quantity, topOrder.quantity);
      const matchPrice = topOrder.price;
      
      // Create trade
      const trade = await this.createTrade({
        buyOrderId: order.side === 'buy' ? order.id : topOrder.id,
        sellOrderId: order.side === 'sell' ? order.id : topOrder.id,
        quantity: matchQuantity,
        price: matchPrice
      });
      
      matches.push(trade);
      
      // Update quantities
      order.quantity -= matchQuantity;
      topOrder.quantity -= matchQuantity;
      
      if (topOrder.quantity === 0) {
        oppositeBook.poll();
      }
    }
    
    // Add remaining quantity to order book
    if (order.quantity > 0) {
      const orderBook = order.side === 'buy' ? this.buyOrders : this.sellOrders;
      orderBook.offer(order);
    }
    
    return matches;
  }
}

WebSocket Real-time Updates

const WebSocket = require('ws');
const Redis = require('redis');

class MarketDataStreamer {
  constructor() {
    this.wss = new WebSocket.Server({ port: 8080 });
    this.redis = Redis.createClient();
    this.subscriptions = new Map();
  }

  start() {
    this.wss.on('connection', (ws) => {
      ws.on('message', (message) => {
        const { action, symbol } = JSON.parse(message);
        
        if (action === 'subscribe') {
          this.subscribe(ws, symbol);
        } else if (action === 'unsubscribe') {
          this.unsubscribe(ws, symbol);
        }
      });
      
      ws.on('close', () => {
        this.cleanup(ws);
      });
    });
    
    // Listen for trade updates from Redis
    this.redis.subscribe('trades', 'orderbook', 'ticker');
    this.redis.on('message', (channel, data) => {
      this.broadcast(channel, JSON.parse(data));
    });
  }

  subscribe(ws, symbol) {
    if (!this.subscriptions.has(symbol)) {
      this.subscriptions.set(symbol, new Set());
    }
    this.subscriptions.get(symbol).add(ws);
    
    // Send initial data
    this.sendInitialData(ws, symbol);
  }

  broadcast(channel, data) {
    const symbol = data.symbol;
    const subscribers = this.subscriptions.get(symbol);
    
    if (subscribers) {
      const message = JSON.stringify({ channel, data });
      subscribers.forEach(ws => {
        if (ws.readyState === WebSocket.OPEN) {
          ws.send(message);
        }
      });
    }
  }
}