Market Data

// Connect to WebSocket server
const ws = new WebSocket('wss://ws.exness.com');

ws.onopen = () => {
  console.log('Connected to price stream');
};

ws.onmessage = (event) => {
  const priceUpdate = JSON.parse(event.data);
  console.log('Price update:', priceUpdate);
  
  // Update UI with new prices
  updatePriceDisplay(priceUpdate);
};

// Price update format
{
  "asset": "BTC_USDC_PERP",
  "bid": 429700,      // Bid price (with 4 decimal precision)
  "ask": 430300       // Ask price (with 4 decimal precision)
}

// apps/Price_Poller/src/index.ts
import WebSocket from "ws";
import { pubsubClient, redisClient, redisStreams } from "@repo/config";

const ws = new WebSocket(config.BINANCE_WS_URL);
const PubsubClient = pubsubClient(config.REDIS_URL);
const RedisStreams = redisStreams(config.REDIS_URL);

const crypto_trades = ["ETH_USDC_PERP", "SOL_USDC_PERP", "BTC_USDC_PERP"];
const price_updates: PriceUpdate[] = [];

// Subscribe to Binance trade streams
ws.on("open", function open() {
  crypto_trades.forEach((asset) => {
    ws.send(`{"method":"SUBSCRIBE","params":["trade.${asset}"],"id":4}`);
  });
});

ws.on("message", async (data) => {
  const msg = JSON.parse(data.toString());
  
  // Calculate bid/ask with 0.5% spread
  const decimal = 4;
  const asset = msg.data.s.toString();
  const price = Math.floor(Number(msg.data.p) * 10 ** decimal);
  const bidValue = Math.floor((price - price * 0.005) * 10 ** decimal);
  const askValue = Math.floor((price + price * 0.005) * 10 ** decimal);
  
  // Publish to WebSocket clients via Redis Pub/Sub
  const bidAsk = { asset, bid: bidValue, ask: askValue };
  await PubsubClient.publish(
    constant.pubsubKey,
    JSON.stringify(bidAsk)
  );
  
  // Update price_updates array
  const idx = price_updates.findIndex((u) => u.asset === asset);
  if (idx !== -1) {
    price_updates[idx] = { asset, price, bidValue, askValue, decimal };
  } else {
    price_updates.push({ asset, price, bidValue, askValue, decimal });
  }
});

// Send to Engine every 3 seconds
setInterval(async () => {
  await RedisStreams.addToRedisStream(
    constant.redisStream,
    {
      function: "pricePoller",
      message: JSON.stringify(price_updates)
    }
  );
}, 3000);

// apps/Backend/src/routes/candles.routes.ts
import { Router } from "express";
import { timeScaleDB } from "@repo/timescaledb";

const candleRouter = Router();
const client = timeScaleDB();

const allowedIntervals = ["1m", "5m", "15m", "30m", "1h", "4h", "1d"];

// Symbol mapping from user-facing to database format
const symbolMapping: Record<string, string> = {
  'BTCUSDT': 'BTC_USDC_PERP',
  'ETHUSDT': 'ETH_USDC_PERP',
  'SOLUSDT': 'SOL_USDC_PERP',
};

export const getCandles = async (req: Request, res: Response) => {
  const { symbol, interval } = req.query;

  // Validate parameters
  if (!symbol || !interval) {
    return res.status(400).json({
      error: "Missing required query parameters: symbol and interval"
    });
  }

  if (!allowedIntervals.includes(interval as string)) {
    return res.status(400).json({
      error: "Invalid interval value",
      allowedIntervals
    });
  }

  // Map symbol to database format
  const inputSymbol = (symbol as string).toUpperCase();
  const dbSymbol = symbolMapping[inputSymbol] || inputSymbol;

  // Get default time range for interval
  const { from, to } = getTimeRange(interval as string);

  // Retrieve data from TimescaleDB
  const data = await retrieveData(dbSymbol, interval as string, from, to);

  return res.json({
    symbol: inputSymbol,
    dbSymbol,
    interval,
    from,
    to,
    count: data.length,
    data
  });
};

candleRouter.get("/", getCandles);

// Connect to WebSocket for real-time updates
const ws = new WebSocket('wss://ws.exness.com');
const prices = {};

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  
  // Store latest prices
  prices[update.asset] = {
    bid: update.bid / 10000,  // Convert to actual price
    ask: update.ask / 10000,
    timestamp: Date.now()
  };
  
  // Update UI
  document.getElementById(`${update.asset}-bid`).textContent = 
    prices[update.asset].bid.toFixed(2);
  document.getElementById(`${update.asset}-ask`).textContent = 
    prices[update.asset].ask.toFixed(2);
};