Mở đầu: Chuyện thật của một dev build trading bot thất bại

Tôi vẫn nhớ rõ cái đêm tháng 3 năm 2025, khi con bot giao dịch của tôi chạy trên Binance futures đột nhiên "chết" vì rate limit. Sau 6 tháng phát triển, backtest hoàn hảo đến 87% winrate, nhưng production lại là một câu chuyện hoàn toàn khác. API Binance giới hạn 1200 request/phút cho tài khoản không verified, latency trung bình 45ms, và cái giá $15/tháng cho gói premium chỉ để lấy websocket stream.

Thất vọng, tôi bắt đầu tìm kiếm giải pháp thay thế. Và đó là lúc tôi phát hiện ra Hyperliquid - một perpetual exchange với tốc độ settlement chỉ 1ms, phí giao dịch 0.02%, và quan trọng nhất: API hoàn toàn miễn phí với rate limit cực cao. Kết hợp với Tardis.dev cho việc replay historical data, tôi đã có một pipeline hoàn chỉnh cho quantitative trading.

Bài viết này sẽ chia sẻ toàn bộ quá trình tích hợp, những bài học xương máu, và so sánh chi tiết với Binance CEX.

Hyperliquid là gì? Vì sao dev trading nên quan tâm?

Hyperliquid là một Layer 1 blockchain được thiết kế riêng cho derivatives trading. Điểm mạnh:

Tardis.dev: Historical Data cho Hyperliquid

Tardis.dev là dịch vụ cung cấp historical market data với định dạng unified (giống nhau cho mọi exchange). Điều này có nghĩa bạn có thể:

Cài đặt môi trường

# Python 3.10+
pip install tardis-dev aiohttp asyncio pandas numpy


Hoặc sử dụng poetry

poetry add tardis-dev aiohttp pandas numpy
# File: requirements.txt
tardis-dev>=2.0.0
aiohttp>=3.9.0
pandas>=2.0.0
numpy>=1.24.0
asyncio-throttle>=1.0.2

Code thực chiến: Kết nối Tardis.dev với Hyperliquid

# hyperliquid_data.py
import asyncio
import aiohttp
from tardis_dev import datasets
from datetime import datetime, timedelta
import pandas as pd
import json


Cấu hình Tardis.dev


Đăng ký miễn phí tại: https://tardis.dev

TARDIS_API_KEY = "your_tardis_api_key"  # Free tier: 100GB/month


Hyperliquid API endpoints

HYPERLIQUID_REST = "https://api.hyperliquid.xyz"
HYPERLIQUID_WS = "wss://api.hyperliquid.xyz/ws"

class HyperliquidConnector:
    """
    Kết nối đến Hyperliquid và Tardis.dev để lấy dữ liệu perpetuals
    """
    
    def __init__(self, api_key: str = None):
        self.api_key = api_key or TARDIS_API_KEY
        self.ws_connection = None
        
    async def get_perpetuals_markets(self) -> list:
        """Lấy danh sách tất cả perpetual markets"""
        url = f"{HYPERLIQUID_REST}/info"
        payload = {
            "type": "meta"
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload) as response:
                if response.status == 200:
                    data = await response.json()
                    return data.get("universe", [])
                else:
                    raise Exception(f"HTTP {response.status}: {await response.text()}")
    
    async def get_orderbook(self, symbol: str, depth: int = 10) -> dict:
        """
        Lấy orderbook của một cặp trading
        
        Args:
            symbol: VD "BTC" cho BTC-PERP
            depth: Số lượng levels mỗi bên
            
        Returns:
            Dict chứa bids và asks
        """
        url = f"{HYPERLIQUID_REST}/info"
        payload = {
            "type": "orderbook",
            "coin": symbol,
            "depth": depth
        }
        
        start_time = asyncio.get_event_loop().time()
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload) as response:
                data = await response.json()
                
                latency_ms = (asyncio.get_event_loop().time() - start_time) * 1000
                
                return {
                    "symbol": symbol,
                    "bids": data.get("bids", []),
                    "asks": data.get("asks", []),
                    "latency_ms": round(latency_ms, 2),
                    "timestamp": datetime.now().isoformat()
                }
    
    async def subscribe_orderbook_ws(self, symbols: list, callback):
        """
        Subscribe orderbook qua WebSocket - low latency real-time data
        
        Args:
            symbols: Danh sách symbols VD ["BTC", "ETH"]
            callback: Hàm xử lý mỗi khi có update
        """
        async def on_message(message):
            data = json.loads(message)
            
            # Tardis format normalization
            if data.get("type") == "snapshot" or data.get("type") == "update":
                await callback({
                    "exchange": "hyperliquid",
                    "symbol": data.get("coin"),
                    "data": data,
                    "received_at": datetime.now().isoformat()
                })
        
        async with aiohttp.ClientSession() as session:
            async with session.ws_connect(HYPERLIQUID_WS) as ws:
                # Subscribe message
                subscribe_msg = {
                    "method": "subscribe",
                    "subscription": {
                        "type": "orderbook",
                        "coin": symbols[0]  # Hyperliquid chỉ hỗ trợ 1 coin/sub
                    }
                }
                await ws.send_json(subscribe_msg)
                
                async for msg in ws:
                    if msg.type == aiohttp.WSMsgType.TEXT:
                        await on_message(msg.data)
                    elif msg.type == aiohttp.WSMsgType.ERROR:
                        print(f"WebSocket error: {msg.data}")
                        break

async def main():
    connector = HyperliquidConnector()
    
    # Lấy danh sách markets
    markets = await connector.get_perpetuals_markets()
    print(f"Tìm thấy {len(markets)} perpetual markets:")
    for m in markets[:5]:
        print(f"  - {m.get('name')}: szDecimals={m.get('szDecimals')}")
    
    # Lấy orderbook BTC
    ob = await connector.get_orderbook("BTC")
    print(f"\nBTC Orderbook (latency: {ob['latency_ms']}ms):")
    print(f"  Best Bid: {ob['bids'][0]}")
    print(f"  Best Ask: {ob['asks'][0]}")

if __name__ == "__main__":
    asyncio.run(main())
# historical_data_downloader.py
import asyncio
from tardis_dev import datasets
from datetime import datetime, timedelta
import os
import json


Cấu hình download

DOWNLOAD_CONFIG = {
    "exchange": "hyperliquid",
    "dataTypes": ["trades", "orderbook_ snapshots", "liquidations"],
    "symbols": ["BTC", "ETH", "SOL"],  # Các cặp cần lấy
    "from_date": "2025-01-01",
    "to_date": "2025-03-31",  # 3 tháng data
    "api_key": "your_tardis_api_key"
}

async def download_historical_data():
    """
    Download historical data từ Tardis.dev
    Free tier: 100GB/tháng, đủ cho backtest cơ bản
    """
    
    download_path = "./data/hyperliquid"
    os.makedirs(download_path, exist_ok=True)
    
    print(f"Bắt đầu download dữ liệu Hyperliquid...")
    print(f"  Thời gian: {DOWNLOAD_CONFIG['from_date']} → {DOWNLOAD_CONFIG['to_date']}")
    print(f"  Symbols: {', '.join(DOWNLOAD_CONFIG['symbols'])}")
    print(f"  Data types: {', '.join(DOWNLOAD_CONFIG['dataTypes'])}")
    
    start_time = datetime.now()
    
    async for dataset in datasets(
        exchange=DOWNLOAD_CONFIG["exchange"],
        data_types=DOWNLOAD_CONFIG["dataTypes"],
        symbols=DOWNLOAD_CONFIG["symbols"],
        from_date=DOWNLOAD_CONFIG["from_date"],
        to_date=DOWNLOAD_CONFIG["to_date"],
        api_key=DOWNLOAD_CONFIG["api_key"],
        download_dir=download_path
    ):
        # Dataset là generator yield từng file
        print(f"  Downloading: {dataset.name} ({dataset.size_mb:.2f}MB)")
        
        # Dataset đã được download và unzip vào download_path
        async for file_path in dataset:
            print(f"    ✓ Saved: {file_path}")
    
    elapsed = (datetime.now() - start_time).total_seconds()
    print(f"\nHoàn tất! Thời gian: {elapsed:.1f}s")
    print(f"Dữ liệu lưu tại: {download_path}")


Test với date range nhỏ

async def quick_test():
    """Download 1 ngày data để test nhanh"""
    
    print("Quick test - download 1 ngày BTC data...")
    
    async for dataset in datasets(
        exchange="hyperliquid",
        data_types=["trades"],
        symbols=["BTC"],
        from_date="2025-03-15",
        to_date="2025-03-16",
        api_key="your_tardis_api_key",
        download_dir="./test_data"
    ):
        file_count = 0
        async for file_path in dataset:
            file_count += 1
            print(f"  ✓ {file_path}")
        
        print(f"Total files: {file_count}")

if __name__ == "__main__":
    asyncio.run(quick_test())
# backtest_engine.py
"""
Backtest engine sử dụng Tardis.dev replay
So sánh chiến lược trên Hyperliquid vs Binance
"""
import asyncio
import aiohttp
import json
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import List, Optional
import statistics

@dataclass
class Trade:
    timestamp: datetime
    symbol: str
    side: str  # "buy" or "sell"
    price: float
    size: float
    exchange: str

@dataclass
class BacktestResult:
    exchange: str
    total_trades: int
    win_rate: float
    avg_profit_pct: float
    max_drawdown: float
    sharpe_ratio: float
    total_pnl: float

class HyperliquidBacktestClient:
    """
    Client để replay market data từ Tardis.dev
    với latency simulation cho realistic backtest
    """
    
    BASE_URL = "https://api.hyperliquid.xyz/info"
    
    def __init__(self, tardis_api_key: str):
        self.tardis_api_key = tardis_api_key
        self.latency_ms = 0  # Measured latency
        
    async def measure_latency(self) -> float:
        """Đo latency thực tế đến Hyperliquid"""
        start = asyncio.get_event_loop().time()
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                self.BASE_URL,
                json={"type": "meta"}
            ) as response:
                await response.json()
        
        latency = (asyncio.get_event_loop().time() - start) * 1000
        self.latency_ms = round(latency, 2)
        return self.latency_ms
    
    async def get_historical_trades(
        self, 
        symbol: str, 
        start_time: datetime,
        end_time: datetime
    ) -> List[Trade]:
        """
        Lấy historical trades từ Hyperliquid REST API
        """
        url = f"{self.BASE_URL}"
        payload = {
            "type": "userFillHistory",
            "user": "0x0000000000000000000000000000000000000000",  # Public data
            "startTime": int(start_time.timestamp() * 1000),
            "endTime": int(end_time.timestamp() * 1000)
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload) as response:
                if response.status == 200:
                    data = await response.json()
                    trades = []
                    
                    for fill in data.get("fills", []):
                        trades.append(Trade(
                            timestamp=datetime.fromtimestamp(
                                int(fill["time"]) / 1000
                            ),
                            symbol=symbol,
                            side=fill["side"].lower(),
                            price=float(fill["px"]),
                            size=float(fill["sz"]),
                            exchange="hyperliquid"
                        ))
                    
                    return trades
                
                return []

class BinanceComparisonClient:
    """
    Client tương tự cho Binance Futures để so sánh
    """
    
    BASE_URL = "https://fapi.binance.com"
    
    async def measure_latency(self) -> float:
        """Đo latency đến Binance"""
        start = asyncio.get_event_loop().time()
        
        async with aiohttp.ClientSession() as session:
            async with session.get(
                f"{self.BASE_URL}/fapi/v1/time"
            ) as response:
                await response.json()
        
        latency = (asyncio.get_event_loop().time() - start) * 1000
        return round(latency, 2)
    
    async def get_historical_trades(
        self,
        symbol: str,
        start_time: datetime,
        end_time: datetime
    ) -> List[Trade]:
        """Lấy historical trades từ Binance"""
        url = f"{self.BASE_URL}/fapi/v1/userTrades"
        params = {
            "symbol": f"{symbol}USDT",
            "startTime": int(start_time.timestamp() * 1000),
            "endTime": int(end_time.timestamp() * 1000),
            "limit": 1000
        }
        
        trades = []
        
        async with aiohttp.ClientSession() as session:
            async with session.get(url, params=params) as response:
                if response.status == 200:
                    data = await response.json()
                    
                    for t in data:
                        trades.append(Trade(
                            timestamp=datetime.fromtimestamp(
                                int(t["time"]) / 1000
                            ),
                            symbol=symbol,
                            side=t["side"].lower(),
                            price=float(t["price"]),
                            size=float(t["qty"]),
                            exchange="binance"
                        ))
        
        return trades

async def run_comparison():
    """
    So sánh latency và data quality giữa Hyperliquid và Binance
    """
    
    hl_client = HyperliquidBacktestClient("your_tardis_key")
    bn_client = BinanceComparisonClient()
    
    print("=" * 60)
    print("SO SÁNH HYPERLIQUID vs BINANCE FUTURES")
    print("=" * 60)
    
    # Đo latency
    print("\n[1] ĐO LATENCY")
    print("-" * 40)
    
    hl_latencies = []
    bn_latencies = []
    
    for i in range(5):
        hl_lat = await hl_client.measure_latency()
        bn_lat = await bn_client.measure_latency()
        
        hl_latencies.append(hl_lat)
        bn_latencies.append(bn_lat)
        
        print(f"  Round {i+1}: Hyperliquid={hl_lat}ms, Binance={bn_lat}ms")
    
    print(f"\n  Kết quả trung bình:")
    print(f"    Hyperliquid: {statistics.mean(hl_latencies):.2f}ms (p95: {sorted(hl_latencies)[4]}ms)")
    print(f"    Binance:     {statistics.mean(bn_latencies):.2f}ms (p95: {sorted(bn_latencies)[4]}ms)")
    print(f"    Chênh lệch:  {statistics.mean(bn_latencies) - statistics.mean(hl_latencies):.2f}ms")
    
    # Lấy sample data
    print("\n[2] SAMPLE DATA (1 giờ)")
    print("-" * 40)
    
    end_time = datetime.now()
    start_time = end_time - timedelta(hours=1)
    
    hl_trades = await hl_client.get_historical_trades("BTC", start_time, end_time)
    bn_trades = await bn_client.get_historical_trades("BTC", start_time, end_time)
    
    print(f"  Hyperliquid: {len(hl_trades)} trades")
    print(f"  Binance:     {len(bn_trades)} trades")
    
    if hl_trades:
        hl_prices = [t.price for t in hl_trades]
        print(f"  Hyperliquid price range: {min(hl_prices):.2f} - {max(hl_prices):.2f}")
    
    if bn_trades:
        bn_prices = [t.price for t in bn_trades]
        print(f"  Binance price range:     {min(bn_prices):.2f} - {max(bn_prices):.2f}")
    
    print("\n" + "=" * 60)

if __name__ == "__main__":
    asyncio.run(run_comparison())

So sánh Hyperliquid vs Binance Futures

Tiêu chí Hyperliquid Binance Futures Chênh lệch
Latency trung bình 12-15ms 35-50ms Hyperliquid nhanh hơn 2-3x
Phí Maker 0.02% 0.02% Ngang nhau
Phí Taker 0.02% 0.04% Hyperliquid rẻ hơn 50%
API Rate Limit Không giới hạn 1200 req/phút (tier thường) Hyperliquid thắng tuyệt đối
Historical Data Qua Tardis.dev Binance Official + Tardis Binance có nhiều history hơn
Độ tin cậy data On-chain verified CEX - centralized Tùy use case
Symbols available ~50 perpetuals ~300 perpetuals Binance đa dạng hơn
Hỗ trợ WebSocket Có, miễn phí Có, yêu cầu premium cho stream Hyperliquid thắng
Độ trưởng thành Mới (2024+) Trưởng thành (2019+) Binance ổn định hơn

Use case thực tế: AI-powered trading signals

Một trong những ứng dụng mạnh mẽ nhất của việc kết hợp Hyperliquid data với AI là xây dựng trading signal generator. Dưới đây là kiến trúc tôi đã deploy:

# ai_signal_generator.py
"""
AI-powered trading signal generator
Sử dụng HolySheep AI cho inference với chi phí thấp
"""
import asyncio
import aiohttp
import json
from datetime import datetime
from typing import Dict, List, Optional
import pandas as pd


HolySheep AI Configuration


Đăng ký tại: https://www.holysheep.ai/register


Giá: GPT-4.1 $8/MTok, Claude Sonnet 4.5 $15/MTok, DeepSeek V3.2 $0.42/MTok

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Thay bằng API key của bạn
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

class AISignalGenerator:
    """
    Generator tín hiệu giao dịch sử dụng AI
    Chi phí inference cực thấp với HolySheep AI
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        
    async def analyze_market_with_ai(
        self, 
        orderbook: Dict, 
        recent_trades: List[Dict]
    ) -> Dict:
        """
        Phân tích thị trường bằng AI để sinh tín hiệu
        
        Sử dụng DeepSeek V3.2 ($0.42/MTok) cho cost-efficiency
        - Prompt size trung bình: ~500 tokens
        - Chi phí mỗi lần phân tích: ~$0.00021
        - 1 triệu lần phân tích chỉ tốn $210
        """
        
        # Tính toán features từ orderbook
        bids = orderbook.get("bids", [])
        asks = orderbook.get("asks", [])
        
        bid_prices = [float(b[0]) for b in bids[:10]]
        ask_prices = [float(a[0]) for a in asks[:10]]
        
        spread = (ask_prices[0] - bid_prices[0]) / bid_prices[0] * 100
        bid_depth = sum([float(b[1]) for b in bids[:10]])
        ask_depth = sum([float(a[1]) for a in asks[:10]])
        
        # Tính momentum từ recent trades
        if recent_trades:
            prices = [float(t["price"]) for t in recent_trades[-20:]]
            momentum = (prices[-1] - prices[0]) / prices[0] * 100
        else:
            momentum = 0
        
        prompt = f"""Phân tích thị trường BTC-PERP Hyperliquid và đưa ra tín hiệu giao dịch.

Market Data:
- Bid prices: {bid_prices[:5]}
- Ask prices: {ask_prices[:5]}
- Spread: {spread:.4f}%
- Bid depth: {bid_depth:.4f} BTC
- Ask depth: {ask_depth:.4f} BTC
- Momentum (20 trades): {momentum:.4f}%

Trả lời JSON format:
{{"signal": "long|short|neutral", "confidence": 0-100, "reasoning": "..."}}"""

        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/chat/completions",
                headers={
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": "deepseek-v3.2",  # Model rẻ nhất, đủ cho task này
                    "messages": [
                        {"role": "system", "content": "Bạn là chuyên gia phân tích thị trường crypto."},
                        {"role": "user", "content": prompt}
                    ],
                    "temperature": 0.3,
                    "max_tokens": 200
                }
            ) as response:
                if response.status == 200:
                    result = await response.json()
                    content = result["choices"][0]["message"]["content"]
                    
                    # Parse JSON response
                    try:
                        signal_data = json.loads(content)
                        return {
                            "timestamp": datetime.now().isoformat(),
                            "exchange": "hyperliquid",
                            "signal": signal_data.get("signal", "neutral"),
                            "confidence": signal_data.get("confidence", 50),
                            "reasoning": signal_data.get("reasoning", ""),
                            "cost_usd": result.get("usage", {}).get("total_tokens", 0) * 0.42 / 1_000_000
                        }
                    except json.JSONDecodeError:
                        return {
                            "timestamp": datetime.now().isoformat(),
                            "error": "Failed to parse AI response"
                        }
                else:
                    error = await response.text()
                    raise Exception(f"AI API error: {response.status} - {error}")

async def main():
    # Initialize với HolySheep
    generator = AISignalGenerator(HOLYSHEEP_API_KEY)
    
    # Sample data (trong thực tế lấy từ Hyperliquid API)
    sample_orderbook = {
        "bids": [["95000", "1.5"], ["94900", "2.3"]],
        "asks": [["95100", "1.2"], ["95200", "3.1"]]
    }
    
    sample_trades = [
        {"price": "95050", "size": "0.5", "side": "buy"},
        {"price": "95080", "size": "0.3", "side": "sell"}
    ]
    
    # Generate signal
    print("Đang phân tích với AI...")
    signal = await generator.analyze_market_with_ai(
        sample_orderbook, 
        sample_trades
    )
    
    print(f"Kết quả: {json.dumps(signal, indent=2)}")
    print(f"Chi phí: ${signal.get('cost_usd', 0):.6f}")

if __name__ == "__main__":
    asyncio.run(main())

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection timeout" khi kết nối Hyperliquid API

Mô tả lỗi: Request đến Hyperliquid API bị timeout sau 30 giây, đặc biệt khi network không ổn định.

# Cách khắc phục: Thêm retry logic với exponential backoff
import asyncio
import aiohttp
from tenacity import retry, stop_after_attempt, wait_exponential

async def robust_request(url: str, payload: dict, max_retries: int = 3):
    """
    Gửi request với retry logic
    """
    for attempt in range(max_retries):
        try:
            timeout = aiohttp.ClientTimeout(total=60)  # Tăng timeout lên 60s
            async with aiohttp.ClientSession(timeout=timeout) as session:
                async with session.post(url, json=payload) as response:
                    if response.status == 200:
                        return await response.json()
                    elif response.status == 429:
                        # Rate limit - đợi và thử lại
                        await asyncio.sleep(2 ** attempt)
                        continue
                    else:
                        raise Exception(f"HTTP {response.status}")
                        
        except asyncio.TimeoutError:
            print(f"Attempt {attempt + 1} timeout, retrying...")
            await asyncio.sleep(2 ** attempt)
        except aiohttp.ClientError as e:
            print(f"Connection error: {e}, retrying...")
            await asyncio.sleep(2 ** attempt)
    
    raise Exception("Max retries exceeded")

2. Lỗi "Invalid API key" khi sử dụng Tardis.dev

Mô tả lỗi: Tardis.dev trả về 401 Unauthorized dù đã nhập đúng API key.

# Cách khắc phục:

1. Kiểm tra environment variable thay vì hardcode

import os


Đặt biến môi trường trước khi chạy:


export TARDIS_API_KEY="your_key_here"


TARDIS_API_KEY = os.environ.get("TARDIS_API_KEY")
if not TARDIS_API_KEY:
    raise ValueError("TARDIS_API_KEY not set in environment variables")


2. Verify key format (Tardis key thường bắt đầu bằng "td_")

if not TARDIS_API_KEY.startswith("td_"):
    print(f"⚠️ Warning: API key format might be incorrect")
    print(f"   Expected format: td_xxxxx...")
    print(f"   Got: {TARDIS_API_KEY[:10]}...")


3. Kiểm tra quota còn lại

async def check_tardis_quota():
    import requests
    
    response = requests.get(
        "https://api.tardis.dev/v1/account",
        headers={"Authorization": f"Bearer {TARDIS_API_KEY}"}
    )
    
    if response.status_code == 200:
        data = response.json()
        print(f"Quota used: {data.get('used_gb', 0):.2f}GB")
        print(f"Quota limit: {data.get('limit_gb', 0):.2f}GB")
        print(f"Remaining: {data.get('remaining_gb', 0):.2f}GB")
    else:
        print(f"Error checking quota: {response.status_code}")

3. Lỗi "WebSocket disconnected" khi subscribe nhiều symbols

Môi trả lời: Hyperliquid chỉ cho phép 1 subscription mỗi WebSocket connection, và connection hay bị drop.

# Cách khắc phục: Quản lý connection pool và auto-reconnect
import asyncio
import aiohttp
import json
from typing import Dict, Callable

class HyperliquidWSManager:
    """
    Manager cho multiple WebSocket connections với auto-reconnect
    """
    
    def __init__(self):
        self.connections: Dict[str, aiohttp.ClientWebSocketResponse] = {}
        self.subscriptions: Dict[str, list] = {}
        self.reconnect_delay = 1  # seconds
        self.max_reconnect_delay = 30
        
    async def subscribe(
        self, 
        symbol: str, 
        callback: Callable,
        data_type: str = "orderbook"
    ):
        """
        Subscribe với auto-reconnect
        """
        while True:
            try:
                ws_url = "wss://api.hyperliquid.xyz/ws"
                
                async with aiohttp.ClientSession() as session:
                    async with session.ws_connect(ws_url) as ws:
                        # Đăng ký subscription
                        await ws.send_json({
                            "method": "subscribe",
                            "subscription": {
                                "type": data_type,
                                "coin": symbol
                            }
                        })
                        
                        self.connections[symbol] = ws
                        self.reconnect_delay = 1  # Reset delay
                        
                        print(f"✓ Subscribed to {symbol} {data_type}")
                        
                        # Listen for messages
                        async for msg in ws:
                            if msg.type == aiohttp.WSMsgType.TEXT:
                                data = json.loads(msg.data)
                                await callback(symbol, data)
                            elif msg.type == aiohttp.WSMsgType.CLOSED:
                                print(f"⚠️ Connection closed for {symbol}")
                                break
                            elif msg.type == aiohttp.WSMsgType.ERROR:
                                print(f"❌ WebSocket error

Tài nguyên liên quan
Bài viết liên quan