WebSocket Streams

MuchFi provides two WebSocket services for real-time market data streaming:

Main WebSocket - Real-time trading data for pairs, tokens, and pools
Aggregated WebSocket - Aggregated token data with price and volume alerts

Both services use Socket.IO for reliable WebSocket connections.

Main WebSocket

Connection

import { io } from "socket.io-client";

const socket = io("wss://ws.integrated-api.testnet.muchfi.xyz", {
  transports: ["websocket"],
});

socket.on("connect", () => {
  console.log("Connected:", socket.id);
});

Available Channels

Channel	Description
`subscribe:pairs`	Subscribe to pair price and candle updates
`subscribe:tokens`	Subscribe to token candle updates
`subscribe:datafeed`	TradingView-compatible OHLCV datafeed
`subscribe:token-datafeed`	Token-specific candlestick datafeed
`subscribe:trades`	Real-time trade updates for a pair
`subscribe:pool-markets`	Pool market data (price, liquidity, volume)
`subscribe:pool`	Unified pool stream (trades + candles)

Supported Intervals

1m, 2m, 3m, 5m, 10m, 15m, 20m, 30m, 1h, 2h, 4h, 1d, 1w, 1mo

Pair Subscriptions

Subscribe to real-time price and candle updates for trading pairs.

socket.emit("subscribe:pairs", {
  pairs: ["0x1234...abcd", "0x5678...efgh"],
  intervals: ["1m", "5m", "1h"]
});

Events Received

Subscription Confirmed:

socket.on("pairs:subscribed", (data) => {
  console.log("Subscribed to:", data.pairs);
});

Price Snapshot (Initial):

socket.on("pairs:price-snapshot", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

Price Update:

socket.on("pairs:price-update", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

Candle Snapshot (Initial):

socket.on("pairs:candle-snapshot", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume }, marketType }
});

Candle Update:

socket.on("pairs:candle-update", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume } }
});

Unsubscribe

socket.emit("unsubscribe:pairs", {
  pairs: ["0x1234...abcd"]
});

socket.on("pairs:unsubscribed", (data) => {
  console.log("Unsubscribed from:", data.pairs);
});

Token Subscriptions

Subscribe to candle updates for specific tokens across all pools.

socket.emit("subscribe:tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."],
  intervals: ["1m", "15m"]
});

Events Received

Subscription Confirmed:

socket.on("tokens:subscribed", (data) => {
  console.log("Subscribed to tokens:", data.tokens);
});

Candle Snapshot:

socket.on("tokens:candle-snapshot", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume } }
});

Candle Update:

socket.on("tokens:candle-update", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume, volumeUSD, txCount } }
});

Datafeed (TradingView Compatible)

Subscribe to OHLCV data for TradingView charting integration.

socket.emit("subscribe:datafeed", {
  market: "0xpoolAddress...",
  marketType: "amm", // "amm" | "clmm" | "launchpad"
  period: 5 // Period in minutes: 1, 5, 15, 60, 240, 1440, etc.
});

Period Mapping:

Period (minutes)	Interval
1	1m
5	5m
15	15m
60	1h
240	4h
1440	1d
10080	1w

Events Received

Subscription Confirmed:

socket.on("datafeed:subscribed", (data) => {
  // { market, marketType, period }
});

Datafeed Snapshot (Historical Candles):

socket.on("datafeed:snapshot", (data) => {
  // { market, marketType, period, candles: [{ time, open, high, low, close, volume }] }
});

Datafeed Update:

socket.on("datafeed:update", (data) => {
  // { market, marketType, period, data: { time, open, high, low, close, volume } }
});

Token Datafeed

Subscribe to candlestick data for individual tokens.

socket.emit("subscribe:token-datafeed", {
  token: "0xtokenAddress...",
  period: 5 // Period in minutes
});

Events Received

Subscription Confirmed:

socket.on("token-datafeed:subscribed", (data) => {
  // { token, period }
});

Snapshot:

socket.on("token-datafeed:snapshot", (data) => {
  // { token, period, candles: [{ time, open, high, low, close, volume, volumeUSD, txCount }] }
});

Update:

socket.on("token-datafeed:update", (data) => {
  // { token, period, data: { time, open, high, low, close, volume, volumeUSD, txCount } }
});

Trades Stream

Subscribe to real-time trade executions for a specific pair.

socket.emit("subscribe:trades", {
  pair: "0xpoolAddress..."
});

Events Received

Subscription Confirmed:

socket.on("trades:subscribed", (data) => {
  // { pair }
});

Trades Snapshot (Recent Trades):

socket.on("trades:snapshot", (data) => {
  // { pair, trades: [{ taker, type, price, size, timestamp, transactionHash }] }
});

New Trade:

socket.on("trades:new", (data) => {
  // { taker, type, price, size, timestamp, transactionHash }
});

Trade Data Fields:

Field	Type	Description
`taker`	string	Taker wallet address
`type`	string	Trade type: `"buy"` or `"sell"`
`price`	string	Execution price
`size`	string	Trade size in token units
`timestamp`	number	Unix timestamp
`transactionHash`	string	On-chain transaction hash

Unsubscribe

socket.emit("unsubscribe:trades");

socket.on("trades:unsubscribed", () => {
  console.log("Unsubscribed from trades");
});

Pool Markets

Subscribe to aggregated market data for a pool (price, liquidity, volume, APR).

socket.emit("subscribe:pool-markets", {
  pool: "0xpoolAddress..."
});

Events Received

Subscription Confirmed:

socket.on("pool-markets:subscribed", (data) => {
  // { pool }
});

Market Snapshot:

socket.on("pool-markets:snapshot", (data) => {
  /*
  {
    address: "0x...",
    price: "1.234567",
    liquidity: "1000000.00",
    volume24hr: "50000.00",
    apr: "12.500000",
    quoteToken: {
      marketCap: "1000000",
      address: "0x...",
      price: "1.00",
      variation1h: "0.5",
      variation24h: "-1.2"
    },
    baseToken: {
      marketCap: "500000",
      address: "0x...",
      price: "1.234567",
      variation1h: "2.1",
      variation24h: "5.5"
    }
  }
  */
});

Market Update:

socket.on("pool-markets:update", (data) => {
  // Same structure as snapshot
});

Unsubscribe

socket.emit("unsubscribe:pool-markets");

Unified Pool Stream

Subscribe to a unified stream for a pool with trades and candles.

socket.emit("subscribe:pool", {
  poolId: "0xpoolAddress...",
  candlePeriod: 5 // Period in minutes
});

Update Candle Period

socket.emit("update:candlePeriod", {
  poolId: "0xpoolAddress...",
  candlePeriod: 15 // New period
});

Unsubscribe

socket.emit("unsubscribe:pool");

Aggregated WebSocket

The Aggregated WebSocket provides token-level aggregated data across all pools with price and volume alerting.

Connection

const aggregatedSocket = io("wss://ws.integrated-api.testnet.muchfi.xyz", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

aggregatedSocket.on("connected", (data) => {
  console.log("Connected:", data.clientId);
  console.log("Available events:", data.availableEvents);
});

aggregatedSocket.emit("subscribe-tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."]
});

aggregatedSocket.on("subscription-confirmed", (data) => {
  console.log("Subscribed to:", data.tokens);
});

Receive Token Updates

Initial Data:

aggregatedSocket.on("initial-aggregated-data", (data) => {
  // { tokenAddress, data: {...}, timestamp }
});

Real-time Updates:

aggregatedSocket.on("aggregated-update", (data) => {
  /*
  {
    type: "token_update",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.23,
      priceImpactPercent: 0.5,
      instantVolume: 10000,
      triggerPool: { address: "0x..." }
    }
  }
  */
});

Unsubscribe from Tokens

aggregatedSocket.emit("unsubscribe-tokens", {
  tokens: ["0xtoken1..."]
});

Price Alerts

Set alerts to be notified when a token reaches a specific price.

Set Alert

aggregatedSocket.emit("set-price-alert", {
  tokenAddress: "0xtoken...",
  threshold: 1.50, // USD price threshold
  direction: "up", // "up" | "down" | "both"
  timeframe: "1m" // "1m" | "5m" | "15m" | "1h"
});

aggregatedSocket.on("price-alert-set", (data) => {
  console.log("Alert set for", data.tokenAddress, "at $", data.threshold);
});

Alert Triggered

aggregatedSocket.on("price-alert-triggered", (data) => {
  /*
  {
    type: "price_alert",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.52,
      priceChange: 1.5,
      timeframe: "1m",
      threshold: 1.50,
      direction: "up"
    }
  }
  */
});

Remove Alert

aggregatedSocket.emit("remove-price-alert", {
  tokenAddress: "0xtoken..."
});

Volume Alerts

Set alerts for volume spikes on specific tokens.

Set Alert

aggregatedSocket.emit("set-volume-alert", {
  tokenAddress: "0xtoken...",
  thresholdUSD: 50000, // USD volume threshold
  percentageIncrease: 100, // % increase to trigger
  timeframe: "5m" // "1m" | "5m" | "15m"
});

aggregatedSocket.on("volume-alert-set", (data) => {
  console.log("Volume alert set for", data.tokenAddress);
});

Alert Triggered

aggregatedSocket.on("volume-alert-triggered", (data) => {
  /*
  {
    type: "volume_spike",
    data: {
      tokenAddress: "0x...",
      volumeUSD: 75000,
      volumeIncrease: 150,
      timeframe: "5m",
      triggerPool: "0x..."
    }
  }
  */
});

Remove Alert

aggregatedSocket.emit("remove-volume-alert", {
  tokenAddress: "0xtoken..."
});

Error Handling

Both WebSocket services emit error events when something goes wrong.

socket.on("error", (data) => {
  console.error("WebSocket error:", data.message);
});

socket.on("disconnect", (reason) => {
  console.log("Disconnected:", reason);
});

socket.on("server-shutdown", (data) => {
  console.log("Server shutting down:", data.message);
});

Complete Example

import { io } from "socket.io-client";

// Main WebSocket for trading data
const tradingSocket = io("wss://ws.integrated-api.testnet.muchfi.xyz", {
  transports: ["websocket"],
});

// Aggregated WebSocket for token analytics
const aggregatedSocket = io("wss://ws.integrated-api.testnet.muchfi.xyz", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

// Trading socket events
tradingSocket.on("connect", () => {
  console.log("Trading socket connected");

  // Subscribe to pair updates
  tradingSocket.emit("subscribe:pairs", {
    pairs: ["0x1234567890abcdef..."],
    intervals: ["1m", "5m"]
  });

  // Subscribe to trades
  tradingSocket.emit("subscribe:trades", {
    pair: "0x1234567890abcdef..."
  });
});

tradingSocket.on("pairs:price-update", (data) => {
  console.log(`Price update: ${data.pair} = $${data.price}`);
});

tradingSocket.on("trades:new", (trade) => {
  console.log(`New trade: ${trade.type} ${trade.size} @ ${trade.price}`);
});

// Aggregated socket events
aggregatedSocket.on("connected", (data) => {
  console.log("Aggregated socket connected:", data.clientId);

  // Subscribe to token updates
  aggregatedSocket.emit("subscribe-tokens", {
    tokens: ["0xabcdef1234567890..."]
  });

  // Set price alert
  aggregatedSocket.emit("set-price-alert", {
    tokenAddress: "0xabcdef1234567890...",
    threshold: 2.00,
    direction: "up",
    timeframe: "5m"
  });
});

aggregatedSocket.on("aggregated-update", (data) => {
  console.log(`Token update: $${data.data.priceUSD}`);
});

aggregatedSocket.on("price-alert-triggered", (alert) => {
  console.log(`Price alert! ${alert.data.tokenAddress} reached $${alert.data.priceUSD}`);
});

WebSocket Streams

On this page