Kết luận trước: Để xây dựng hệ thống backtest đơn hàng OKX hiệu quả, bạn cần kết hợp HolySheep AI cho phân tích dữ liệu và xử lý mô hình AI, trong khi dùng API chính thức OKX để lấy dữ liệu thị trường thời gian thực. HolySheep cung cấp độ trễ dưới 50ms, chi phí chỉ từ $0.42/MTok với mô hình DeepSeek V3.2, giúp bạn tiết kiệm 85% chi phí so với GPT-4.1 ($8/MTok).

Bảng so sánh giải pháp API cho backtest OKX

Tiêu chí HolySheep AI OKX Official API CoinGecko Kaiko
Độ trễ trung bình <50ms 20-100ms 500-2000ms 100-300ms
Chi phí (DeepSeek V3.2) $0.42/MTok Miễn phí (rate limit) $25-500/tháng $500-2000/tháng
Chi phí (GPT-4.1) $8/MTok — — —
Phương thức thanh toán WeChat, Alipay, USDT — Card quốc tế Card quốc tế, wire
Độ phủ mô hình GPT-4.1, Claude 4.5, Gemini 2.5, DeepSeek V3.2 Không có Không có Không có
Hỗ trợ tiếng Việt ✅ Đầy đủ ❌ Tiếng Anh ❌ Tiếng Anh ❌ Tiếng Anh
Nhóm phù hợp Dev Việt, trader tự động Lập trình viên chuyên nghiệp Nghiên cứu định giá Institutional trading

Phù hợp / Không phù hợp với ai

✅ Nên dùng HolySheep AI khi:

❌ Không phù hợp khi:

1. Giới thiệu Order Book và tầm quan trọng trong Backtest

Order book (sổ lệnh) là lớp dữ liệu thô nhất phản ánh cung-cầu thị trường tại mỗi thời điểm. Với OKX perpetual futures, cấu trúc order book bao gồm:

Trong backtest, order book cho phép bạn mô phỏng slippage thực tế, kiểm tra thanh khoản tại các mức giá khác nhau, và phát hiện liquidity gaps — những thứ không thể thấy chỉ từ OHLCV thông thường.

2. Kiến trúc hệ thống Backtest

┌─────────────────────────────────────────────────────────────────┐
│                    KIẾN TRÚC BACKTEST OKX                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │  OKX REST    │───▶│  Data        │───▶│  Backtest    │      │
│  │  WebSocket   │    │  Warehouse   │    │  Engine      │      │
│  │  API         │    │  (SQLite)    │    │              │      │
│  └──────────────┘    └──────────────┘    └──────┬───────┘      │
│                                                │               │
│                                                ▼               │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │  HolySheep   │◀───│  Strategy    │◀───│  Analytics   │      │
│  │  AI API      │    │  Generator   │    │  Dashboard   │      │
│  └──────────────┘    └──────────────┘    └──────────────┘      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

3. Cài đặt môi trường và thư viện

# requirements.txt
pandas>=2.0.0
numpy>=1.24.0
requests>=2.28.0
websocket-client>=1.5.0
sqlalchemy>=2.0.0
python-dotenv>=1.0.0
okx-sdk>=1.0.0  # Official OKX Python SDK


Tạo virtual environment

python -m venv venv_backtest
source venv_backtest/bin/activate  # Linux/Mac

venv_backtest\Scripts\activate  # Windows



Cài đặt dependencies

pip install -r requirements.txt

4. Module lấy dữ liệu Order Book từ OKX

import requests
import time
import json
from datetime import datetime
from typing import Dict, List, Optional
import pandas as pd

class OKXOrderBookCollector:
    """
    Bộ thu thập dữ liệu order book từ OKX REST API
    API Endpoint: https://www.okx.com/api/v5/market/books-lite
    """
    
    BASE_URL = "https://www.okx.com/api/v5/market/books-lite"
    
    def __init__(self, inst_id: str = "BTC-USDT-SWAP"):
        self.inst_id = inst_id
        self.last_request_time = 0
        self.rate_limit = 0.2  # 5 requests/second max cho free tier
        
    def get_order_book(self, sz: int = 400) -> Optional[Dict]:
        """
        Lấy snapshot order book hiện tại
        
        Args:
            sz: Số lượng level mỗi bên (tối đa 400)
            
        Returns:
            Dict chứa bids, asks, timestamp, spread
        """
        # Rate limiting
        elapsed = time.time() - self.last_request_time
        if elapsed < self.rate_limit:
            time.sleep(self.rate_limit - elapsed)
        
        params = {
            "instId": self.inst_id,
            "sz": sz
        }
        
        try:
            response = requests.get(
                self.BASE_URL, 
                params=params,
                timeout=10
            )
            self.last_request_time = time.time()
            
            if response.status_code == 200:
                data = response.json()
                if data.get("code") == "0":
                    return self._parse_order_book(data["data"][0])
                else:
                    print(f"API Error: {data.get('msg')}")
                    return None
            else:
                print(f"HTTP Error: {response.status_code}")
                return None
                
        except Exception as e:
            print(f"Kết nối thất bại: {e}")
            return None
    
    def _parse_order_book(self, raw_data: Dict) -> Dict:
        """Parse và chuẩn hóa dữ liệu order book"""
        
        bids = [
            {"price": float(b[0]), "qty": float(b[1])} 
            for b in raw_data.get("bids", [])
        ]
        asks = [
            {"price": float(a[0]), "qty": float(a[1])} 
            for a in raw_data.get("asks", [])
        ]
        
        best_bid = bids[0]["price"] if bids else 0
        best_ask = asks[0]["price"] if asks else 0
        mid_price = (best_bid + best_ask) / 2
        spread = best_ask - best_bid
        spread_pct = (spread / mid_price) * 100 if mid_price > 0 else 0
        
        return {
            "timestamp": int(raw_data["ts"]),
            "datetime": datetime.fromtimestamp(int(raw_data["ts"]) / 1000),
            "inst_id": raw_data["instId"],
            "bids": bids,
            "asks": asks,
            "best_bid": best_bid,
            "best_ask": best_ask,
            "mid_price": mid_price,
            "spread": spread,
            "spread_pct": spread_pct,
            "bid_depth_10": sum(b["qty"] for b in bids[:10]),
            "ask_depth_10": sum(a["qty"] for a in asks[:10]),
            "imbalance": (sum(b["qty"] for b in bids[:10]) - sum(a["qty"] for a in asks[:10])) /
                         (sum(b["qty"] for b in bids[:10]) + sum(a["qty"] for a in asks[:10]) + 1e-9)
        }
    
    def get_historical_snapshot(self, after: int = None, limit: int = 100) -> List[Dict]:
        """
        Lấy nhiều snapshot order book cho backtest
        Lưu ý: OKX chỉ cho phép lấy ~100 records gần nhất
        """
        params = {
            "instId": self.inst_id,
            "sz": limit
        }
        if after:
            params["after"] = after
            
        # Demo: Tạo synthetic data cho backtest dài hạn
        # Trong production, bạn cần dùng dữ liệu từ data vendor
        return self._generate_synthetic_snapshots(limit)
    
    def _generate_synthetic_snapshots(self, count: int) -> List[Dict]:
        """Tạo synthetic order book data cho testing"""
        import random
        import numpy as np
        
        snapshots = []
        base_price = 43500.0  # BTC price reference
        
        for i in range(count):
            timestamp = int((datetime.now().timestamp() - (count - i) * 60) * 1000)
            mid = base_price + np.random.randn() * 100
            
            bids = [
                {"price": round(mid - 0.5 * j - random.uniform(0, 0.5), 1), 
                 "qty": round(random.uniform(0.1, 5.0), 4)}
                for j in range(20)
            ]
            asks = [
                {"price": round(mid + 0.5 * j + random.uniform(0, 0.5), 1), 
                 "qty": round(random.uniform(0.1, 5.0), 4)}
                for j in range(20)
            ]
            
            snapshot = self._parse_order_book({
                "ts": str(timestamp),
                "instId": self.inst_id,
                "bids": [[b["price"], b["qty"]] for b in bids],
                "asks": [[a["price"], a["qty"]] for a in asks]
            })
            snapshots.append(snapshot)
            
        return snapshots


Sử dụng

collector = OKXOrderBookCollector("BTC-USDT-SWAP")
snapshot = collector.get_order_book()
print(f"Mid Price: ${snapshot['mid_price']:,.2f}")
print(f"Spread: ${snapshot['spread']:.2f} ({snapshot['spread_pct']:.4f}%)")
print(f"Order Imbalance: {snapshot['imbalance']:.4f}")

5. Engine Backtest với Order Book Data

import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import List, Dict, Optional, Callable
from datetime import datetime, timedelta
from enum import Enum

class OrderSide(Enum):
    BUY = "BUY"
    SELL = "SELL"

class OrderType(Enum):
    MARKET = "MARKET"
    LIMIT = "LIMIT"
    STOP = "STOP"

@dataclass
class Order:
    order_id: str
    timestamp: datetime
    side: OrderSide
    order_type: OrderType
    price: float
    quantity: float
    filled_price: float = 0.0
    status: str = "pending"
    slippage: float = 0.0

@dataclass
class TradeSignal:
    timestamp: datetime
    action: str  # "BUY", "SELL", "HOLD"
    confidence: float
    reason: str
    target_price: float = 0.0

class OrderBookBacktestEngine:
    """
    Engine backtest dựa trên order book data
    Tính toán slippage và fill rate thực tế
    """
    
    def __init__(self, initial_capital: float = 10000.0, commission: float = 0.0004):
        """
        Args:
            initial_capital: Vốn ban đầu (USD)
            commission: Phí giao dịch OKX perpetual (0.04% mỗi bên)
        """
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.commission = commission
        self.position = 0.0  # Số lượng contract
        
        self.orders: List[Order] = []
        self.equity_curve: List[Dict] = []
        self.trades: List[Dict] = []
        
    def calculate_slippage(self, order_book: Dict, side: OrderSide, 
                          quantity: float) -> tuple[float, float]:
        """
        Tính slippage thực tế dựa trên order book
        
        Returns:
            (filled_price, slippage_pct)
        """
        if side == OrderSide.BUY:
            levels = order_book["asks"]
        else:
            levels = order_book["bids"]
        
        remaining_qty = quantity
        total_cost = 0.0
        
        for level in levels:
            fill_qty = min(remaining_qty, level["qty"])
            total_cost += fill_qty * level["price"]
            remaining_qty -= fill_qty
            
            if remaining_qty <= 0:
                break
        
        if remaining_qty > 0:
            # Không đủ thanh khoản -> dùng giá cuối cùng với penalty
            last_price = levels[-1]["price"]
            total_cost += remaining_qty * last_price * 1.01  # 1% penalty
            
        avg_price = total_cost / quantity
        mid_price = order_book["mid_price"]
        
        if side == OrderSide.BUY:
            slippage_pct = (avg_price - mid_price) / mid_price * 100
        else:
            slippage_pct = (mid_price - avg_price) / mid_price * 100
            
        return avg_price, slippage_pct
    
    def execute_market_order(self, timestamp: datetime, 
                            order_book: Dict,
                            side: OrderSide, 
                            quantity: float) -> Order:
        """Thực thi lệnh market với slippage simulation"""
        
        filled_price, slippage_pct = self.calculate_slippage(
            order_book, side, quantity
        )
        
        commission_cost = quantity * filled_price * self.commission
        total_cost = quantity * filled_price + commission_cost
        
        order = Order(
            order_id=f"order_{len(self.orders)}_{int(timestamp.timestamp())}",
            timestamp=timestamp,
            side=side,
            order_type=OrderType.MARKET,
            price=filled_price,
            quantity=quantity,
            filled_price=filled_price,
            status="filled",
            slippage=slippage_pct
        )
        
        if side == OrderSide.BUY:
            self.capital -= total_cost
            self.position += quantity
        else:
            self.capital += total_cost
            self.position -= quantity
            
        self.orders.append(order)
        self.trades.append({
            "timestamp": timestamp,
            "side": side.value,
            "quantity": quantity,
            "price": filled_price,
            "slippage": slippage_pct,
            "commission": commission_cost,
            "capital": self.capital,
            "position": self.position
        })
        
        return order
    
    def run_backtest(self, snapshots: List[Dict], 
                    strategy_fn: Callable[[Dict, float, float], TradeSignal],
                    position_size_fn: Callable[[Dict, float], float] = None):
        """
        Chạy backtest với chiến lược được cung cấp
        
        Args:
            snapshots: Danh sách order book snapshots
            strategy_fn: Hàm trả về TradeSignal
            position_size_fn: Hàm tính size (mặc định fixed 10%)
        """
        if position_size_fn is None:
            position_size_fn = lambda ob, cap: cap * 0.1 / ob["mid_price"]
        
        print(f"Bắt đầu backtest với {len(snapshots)} snapshots")
        print(f"Vốn ban đầu: ${self.initial_capital:,.2f}")
        
        for i, snapshot in enumerate(snapshots):
            if i % 100 == 0:
                print(f"Tiến trình: {i}/{len(snapshots)} ({i/len(snapshots)*100:.1f}%)")
            
            # Lấy tín hiệu từ chiến lược
            signal = strategy_fn(snapshot, self.position, self.capital)
            
            if signal and signal.action != "HOLD":
                # Tính position size
                size = position_size_fn(snapshot, self.capital)
                
                if signal.action == "BUY" and self.position == 0:
                    order = self.execute_market_order(
                        snapshot["datetime"],
                        snapshot,
                        OrderSide.BUY,
                        size
                    )
                    print(f"BUY {size:.4f} @ ${order.filled_price:,.2f} "
                          f"(slippage: {order.slippage:.4f}%)")
                          
                elif signal.action == "SELL" and self.position > 0:
                    order = self.execute_market_order(
                        snapshot["datetime"],
                        snapshot,
                        OrderSide.SELL,
                        abs(self.position)
                    )
                    print(f"SELL {abs(self.position):.4f} @ ${order.filled_price:,.2f}")
            
            # Ghi equity curve
            self.equity_curve.append({
                "timestamp": snapshot["datetime"],
                "equity": self.capital + self.position * snapshot["mid_price"],
                "position": self.position,
                "price": snapshot["mid_price"]
            })
        
        self._print_summary()
    
    def _print_summary(self):
        """In tổng kết backtest"""
        equity_df = pd.DataFrame(self.equity_curve)
        
        total_return = (self.capital - self.initial_capital) / self.initial_capital * 100
        sharpe = self._calculate_sharpe(equity_df["equity"])
        max_dd = self._calculate_max_drawdown(equity_df["equity"])
        
        print("\n" + "="*50)
        print("KẾT QUẢ BACKTEST")
        print("="*50)
        print(f"Tổng return: {total_return:.2f}%")
        print(f"Sharpe Ratio: {sharpe:.2f}")
        print(f"Max Drawdown: {max_dd:.2f}%")
        print(f"Số giao dịch: {len(self.orders)}")
        print(f"Vốn cuối: ${self.capital:,.2f}")
        
    def _calculate_sharpe(self, equity: pd.Series, risk_free: float = 0.0) -> float:
        returns = equity.pct_change().dropna()
        if len(returns) == 0:
            return 0.0
        return (returns.mean() - risk_free) / returns.std() * np.sqrt(252)
    
    def _calculate_max_drawdown(self, equity: pd.Series) -> float:
        running_max = equity.expanding().max()
        drawdown = (equity - running_max) / running_max * 100
        return drawdown.min()


Chiến lược mẫu: Imbalance-based mean reversion

def imbalance_strategy(order_book: Dict, position: float, capital: float) -> Optional[TradeSignal]:
    """
    Chiến lược mean reversion dựa trên order imbalance
    
    Logic:
    - Imbalance > 0.15: Quá nhiều bid -> giá sẽ tăng -> BUY
    - Imbalance < -0.15: Quá nhiều ask -> giá sẽ giảm -> SELL
    """
    imbalance = order_book["imbalance"]
    spread_pct = order_book["spread_pct"]
    
    # Chỉ giao dịch khi spread thấp (thanh khoản tốt)
    if spread_pct > 0.05:
        return None
        
    if imbalance > 0.15 and position == 0:
        return TradeSignal(
            timestamp=order_book["datetime"],
            action="BUY",
            confidence=abs(imbalance),
            reason=f"Strong bid imbalance: {imbalance:.4f}"
        )
    elif imbalance < -0.15 and position > 0:
        return TradeSignal(
            timestamp=order_book["datetime"],
            action="SELL",
            confidence=abs(imbalance),
            reason=f"Strong ask imbalance: {imbalance:.4f}"
        )
    
    return None


Chạy backtest

collector = OKXOrderBookCollector("BTC-USDT-SWAP")
snapshots = collector.get_historical_snapshot(limit=500)

engine = OrderBookBacktestEngine(initial_capital=10000)
engine.run_backtest(snapshots, imbalance_strategy)

6. Tích hợp HolySheep AI cho phân tích nâng cao

Bạn có thể dùng HolySheep AI để phân tích order book patterns bằng AI, xử lý tin tức sentiment, hoặc tối ưu hóa tham số chiến lược. Dưới đây là ví dụ tích hợp:

import requests
from typing import List, Dict

class HolySheepAIAnalyzer:
    """
    Tích hợp HolySheep AI để phân tích order book patterns
    Base URL: https://api.holysheep.ai/v1
    """
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def analyze_order_book_pattern(self, order_book: Dict) -> Dict:
        """
        Dùng AI phân tích pattern của order book
        Chi phí: ~1000 tokens × $0.42/MTok = $0.00042 (DeepSeek V3.2)
        """
        prompt = f"""Phân tích order book của BTC-USDT perpetual:

Giá hiện tại: ${order_book['mid_price']:,.2f}
Best Bid: ${order_book['best_bid']:,.2f}
Best Ask: ${order_book['best_ask']:,.2f}
Spread: ${order_book['spread']:.2f} ({order_book['spread_pct']:.4f}%)
Order Imbalance: {order_book['imbalance']:.4f}
Bid Depth (10 levels): {order_book['bid_depth_10']:.4f} BTC
Ask Depth (10 levels): {order_book['ask_depth_10']:.4f} BTC

Phân tích:
1. Đánh giá liquidity (tốt/trung bình/kém)
2. Dự đoán movement ngắn hạn (tăng/giảm/sideways)
3. Risk level (thấp/trung bình/cao)
4. Khuyến nghị hành động

Trả lời ngắn gọn, có dữ liệu cụ thể."""

        payload = {
            "model": "deepseek-chat",  # $0.42/MTok - tiết kiệm 85%
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,
            "max_tokens": 200
        }
        
        try:
            response = requests.post(
                f"{self.BASE_URL}/chat/completions",
                headers=self.headers,
                json=payload,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                return {
                    "analysis": result["choices"][0]["message"]["content"],
                    "model": "deepseek-chat",
                    "usage": result.get("usage", {})
                }
            else:
                print(f"Lỗi API: {response.status_code} - {response.text}")
                return None
                
        except Exception as e:
            print(f"Kết nối HolySheep thất bại: {e}")
            return None
    
    def optimize_strategy_parameters(self, backtest_results: Dict) -> Dict:
        """
        Dùng AI để đề xuất tối ưu hóa tham số chiến lược
        """
        prompt = f"""Dựa trên kết quả backtest:

- Total Return: {backtest_results.get('total_return', 0):.2f}%
- Sharpe Ratio: {backtest_results.get('sharpe', 0):.2f}
- Max Drawdown: {backtest_results.get('max_drawdown', 0):.2f}%
- Win Rate: {backtest_results.get('win_rate', 0):.2f}%
- Số giao dịch: {backtest_results.get('num_trades', 0)}

Đề xuất:
1. Các tham số cần điều chỉnh và giá trị mới
2. Risk management improvements
3. Entry/exit timing optimizations

Trả lời có cấu trúc, có code Python minh họa."""

        payload = {
            "model": "deepseek-chat",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.5,
            "max_tokens": 500
        }
        
        response = requests.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=60
        )
        
        if response.status_code == 200:
            return response.json()["choices"][0]["message"]["content"]
        return None


Sử dụng

analyzer = HolySheepAIAnalyzer("YOUR_HOLYSHEEP_API_KEY")


Phân tích một snapshot

snapshot = collector.get_order_book()
if snapshot:
    analysis = analyzer.analyze_order_book_pattern(snapshot)
    print("Phân tích từ AI:")
    print(analysis["analysis"])
    print(f"\nChi phí API: ${analysis['usage']['total_tokens'] / 1_000_000 * 0.42:.6f}")

7. Lưu trữ dữ liệu với SQLite cho Offline Backtest

from sqlalchemy import create_engine, Column, Float, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import pandas as pd

Base = declarative_base()

class OrderBookSnapshot(Base):
    __tablename__ = 'orderbook_snapshots'
    
    id = Column(Integer, primary_key=True, autoincrement=True)
    timestamp = Column(DateTime, index=True)
    inst_id = Column(String(20))
    mid_price = Column(Float)
    best_bid = Column(Float)
    best_ask = Column(Float)
    spread = Column(Float)
    spread_pct = Column(Float)
    bid_depth_10 = Column(Float)
    ask_depth_10 = Column(Float)
    imbalance = Column(Float)
    bids_json = Column(String)  # JSON string for bids
    asks_json = Column(String)  # JSON string for asks

class DatabaseManager:
    """Quản lý lưu trữ order book data"""
    
    def __init__(self, db_path: str = "orderbook.db"):
        self.engine = create_engine(f"sqlite:///{db_path}")
        Base.metadata.create_all(self.engine)
        Session = sessionmaker(bind=self.engine)
        self.session = Session()
    
    def save_snapshot(self, snapshot: Dict):
        """Lưu một snapshot vào database"""
        record = OrderBookSnapshot(
            timestamp=snapshot["datetime"],
            inst_id=snapshot["inst_id"],
            mid_price=snapshot["mid_price"],
            best_bid=snapshot["best_bid"],
            best_ask=snapshot["best_ask"],
            spread=snapshot["spread"],
            spread_pct=snapshot["spread_pct"],
            bid_depth_10=snapshot["bid_depth_10"],
            ask_depth_10=snapshot["ask_depth_10"],
            imbalance=snapshot["imbalance"],
            bids_json=str(snapshot["bids"]),
            asks_json=str(snapshot["asks"])
        )
        self.session.add(record)
        self.session.commit()
    
    def save_snapshots_batch(self, snapshots: List[Dict]):
        """Lưu nhiều snapshots cùng lúc"""
        records = [
            OrderBookSnapshot(
                timestamp=s["datetime"],
                inst_id=s["inst_id"],
                mid_price=s["mid_price"],
                best_bid=s["best_bid"],
                best_ask=s["best_ask"],
                spread=s["spread"],
                spread_pct=s["spread_pct"],
                bid_depth_10=s["bid_depth_10"],
                ask_depth_10=s["ask_depth_10"],
                imbalance=s["imbalance"],
                bids_json=str(s["bids"]),
                asks_json=str(s["asks"])
            )
            for s in snapshots
        ]
        self.session.bulk_save_objects(records)
        self.session.commit()
        print(f"Đã lưu {len(records)} snapshots vào database")
    
    def load_snapshots(self, start_time: datetime = None, 
                       end_time: datetime = None) -> List[Dict]:
        """Load snapshots từ database"""
        query = self.session.query(OrderBookSnapshot)
        
        if start_time:
            query = query.filter(OrderBookSnapshot.timestamp >= start_time)
        if end_time:
            query = query.filter(OrderBookSnapshot.timestamp <= end_time)
            
        records = query.order_by(OrderBookSnapshot.timestamp).all()
        
        return [
            {
                "datetime": r.timestamp,
                "inst_id": r.inst_id,
                "mid_price": r.mid_price,
                "best_bid": r.best_bid,
                "best_ask": r.best_ask,
                "spread": r.spread,
                "spread_pct": r.spread_p

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