Giao dịch thuật toán với tín hiệu macro: Hướng dẫn chiến lược FX hoàn chỉnh

Tại sao tín hiệu vĩ mô là nền tảng của giao dịch ngoại hối Algo

Tỷ lệ hối đoái không di chuyển ngẫu nhiên. Chúng phản ánh sức hấp dẫn tương đối của hai nền kinh tế: ngân hàng trung ương nào thắt chặt nhanh hơn, lợi nhuận thực tế cao hơn, chế độ lạm phát nào làm suy giảm sức mua và vốn chảy như là hậu quả. Mỗi xu hướng nhiều tuần lớn trong EUR/USD, AUD/JPY hoặc GBP/USD có thể được truy xuất lại với những thay đổi trong các yếu tố cơ bản này thay đổi được công bố theo lịch trình đã biết và có thể quan sát được thông qua dữ liệu công khai.

Các nhà giao dịch tùy chọn xử lý các tín hiệu này theo cách thủ công. Các nhà kinh doanh thuật toán mã hóa chúng. Hướng dẫn này hướng dẫn bạn xây dựng một chiến lược FX toàn diện dựa trên tín hiệu macro trong Python bằng cách sử dụng FXMacroData làm lớp dữ liệu. Đến cuối, bạn sẽ có một hệ thống hoạt động:

• Nhập tỷ lệ chính sách, lạm phát, việc làm và chênh lệch lợi nhuận trái phiếu cho hai loại tiền tệ thông qua FXMacroData API
• Tính toán điểm số chế độ macro tổng hợp để xác định sự thiên vị theo hướng
• Kéo lịch sử tỷ giá giao ngay FX để cung cấp bối cảnh kỹ thuật
• Lịch cập nhật tín hiệu xung quanh các sự kiện lịch phát hành có tác động cao
• Phát ra tín hiệu dài/ngắn/trung tính với hướng dẫn kích thước vị trí
• Áp dụng các biện pháp kiểm soát rủi ro cơ bản: dừng lỗ, giới hạn kích thước và tắt cửa sổ tin tức

Điều kiện tiên quyết

Trước khi bắt đầu, hãy chắc chắn rằng bạn có những điều sau đây:

• Python 3.9+ tất cả các đoạn trích sử dụng các chú thích kiểu chuẩn
• FXMacroData API đăng ký tại /đăng ký và sao chép khóa của bạn từ bảng điều khiển tài khoản
• Các gói Python requests pandas numpy

pip install requests pandas numpy

Lưu trữ khóa API của bạn như một biến môi trường không bao giờ mã hóa mật khẩu trong các tệp nguồn:

export FXMACRO_API_KEY="YOUR_API_KEY"

Các ví dụ dưới đây là thương mại. EUR/USD, nhưng cùng một mô hình áp dụng cho bất kỳ cặp nào có sẵn trong FXMacroData. EUR và USD cho các loại tiền tệ bạn muốn mô hình hóa.

Bước 1: Nhập Core Macro Indicators

Bốn nhóm chỉ số thúc đẩy phần lớn các động thái ngoại hối cấu trúc: lãi suất chính sách của ngân hàng trung ương, lạm phát giá tiêu dùng, sức khỏe thị trường lao động và lợi nhuận trái phiếu chính phủ. chế độ vĩ mô cho mỗi bên của một cặp tiền tệ.

FXMacroData cung cấp tất cả những điều này thông qua một điểm cuối REST nhất quán: GET /api/v1/announcements/{currency}/{indicator}Mỗi quan sát đều chứa một date, a val (giá trị của chỉ số), và một announcement_datetime chính xác đến giây để bạn luôn biết chính xác khi thị trường tìm ra.

import os
import requests
from datetime import date, timedelta

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY  = os.environ["FXMACRO_API_KEY"]


def fetch_indicator(currency: str, indicator: str, lookback_days: int = 400) -> list[dict]:
    """Fetch the most recent observations for a macro indicator."""
    start = (date.today() - timedelta(days=lookback_days)).isoformat()
    resp = requests.get(
        f"{BASE_URL}/announcements/{currency}/{indicator}",
        params={"api_key": API_KEY, "start": start},
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json().get("data", [])


# Pull the four core series for both sides of EUR/USD
usd_rate      = fetch_indicator("usd", "policy_rate")
eur_rate      = fetch_indicator("eur", "policy_rate")
usd_inflation = fetch_indicator("usd", "inflation")
eur_inflation = fetch_indicator("eur", "inflation")
usd_nfp       = fetch_indicator("usd", "non_farm_payrolls")
usd_unemp     = fetch_indicator("usd", "unemployment")
usd_yield     = fetch_indicator("usd", "gov_bond_10y")
eur_yield     = fetch_indicator("eur", "gov_bond_10y")

tỷ lệ chính sách và Lợi suất trái phiếu 10 năm n định giá lãi suất trực tiếp. lạm phát Các loạt bài này cho thấy liệu một ngân hàng trung ương có phải thắt chặt hơn nữa hay có chỗ để nới lỏng. Số tiền lương không phải nông nghiệp và thất nghiệp hoàn thiện hình ảnh thị trường lao động cho mặt USD.

Bước 2: Tính toán điểm chế độ vĩ mô

Một điểm số chế độ sụp đổ một số chỉ số thành một tín hiệu chỉ đạo duy nhất. Cách tiếp cận ở đây là một cách đơn giản: cho mỗi đồng tiền, so sánh lãi suất chính sách mới nhất, tỷ lệ lạm phát và lợi suất trái phiếu với mức trung bình 12 tháng của riêng họ. chế độ tăng cường; một dưới xu hướng của nó là trong một chế độ suy yếuSự chênh lệch giữa hai điểm cho bạn sự thiên vị hướng của cặp.

import pandas as pd
import numpy as np


def latest_val(series: list[dict]) -> float | None:
    """Return the most recent value from a sorted indicator series."""
    if not series:
        return None
    return series[-1]["val"]


def rolling_zscore(series: list[dict], window: int = 12) -> float | None:
    """Z-score of the latest value relative to the last `window` observations."""
    vals = [r["val"] for r in series if r.get("val") is not None]
    if len(vals) < 2:
        return None
    arr = np.array(vals[-window:], dtype=float)
    mu, sigma = arr.mean(), arr.std()
    if sigma == 0:
        return 0.0
    return float((arr[-1] - mu) / sigma)


def macro_score(
    policy_rate: list[dict],
    inflation:   list[dict],
    bond_yield:  list[dict],
) -> float:
    """
    Composite macro score for one currency.
    Positive → strengthening macro backdrop.
    Negative → weakening macro backdrop.
    """
    weights = {"policy_rate": 0.40, "inflation": 0.30, "bond_yield": 0.30}
    scores = {
        "policy_rate": rolling_zscore(policy_rate),
        "inflation":   rolling_zscore(inflation),
        "bond_yield":  rolling_zscore(bond_yield),
    }
    total, weight_sum = 0.0, 0.0
    for key, w in weights.items():
        z = scores[key]
        if z is not None:
            total      += w * z
            weight_sum += w
    return total / weight_sum if weight_sum > 0 else 0.0


usd_score = macro_score(usd_rate, usd_inflation, usd_yield)
eur_score = macro_score(eur_rate, eur_inflation, eur_yield)

# Positive → USD macro stronger → bias SHORT EUR/USD
# Negative → EUR macro stronger → bias LONG EUR/USD
regime_spread = usd_score - eur_score
print(f"USD macro score: {usd_score:+.3f}")
print(f"EUR macro score: {eur_score:+.3f}")
print(f"Regime spread (USD − EUR): {regime_spread:+.3f}")

Bước 3: Thêm bối cảnh thị trường lao động cho USD

Đối với các cặp USD cụ thể, thị trường lao động thường vượt qua tín hiệu lãi suất trong ngắn hạn. Một bản in bảng lương bùng nổ có thể thúc đẩy Fed tạm dừng cắt giảm ngay cả khi lạm phát giảm; một sự tăng đột ngột về thất nghiệp có thể đẩy nhanh kỳ vọng giảm nhẹ. Bao gồm một thành phần việc làm làm làm tăng điểm số USD xung quanh các cửa sổ dữ liệu có tác động cao.

def employment_score(nfp: list[dict], unemployment: list[dict]) -> float:
    """
    Labour market contribution to the USD score.
    Positive NFP momentum + falling unemployment → bullish.
    """
    nfp_z   = rolling_zscore(nfp)
    unemp_z = rolling_zscore(unemployment)

    if nfp_z is None and unemp_z is None:
        return 0.0
    score = 0.0
    count = 0
    if nfp_z is not None:
        score += 0.60 * nfp_z   # NFP gets more weight
        count += 1
    if unemp_z is not None:
        # Unemployment is inverse: a rising z-score is bearish for USD
        score -= 0.40 * unemp_z
        count += 1
    return score


usd_employment = employment_score(usd_nfp, usd_unemp)

# Rebuild USD score including labour market
usd_score_full = (
    0.35 * (rolling_zscore(usd_rate) or 0.0) +
    0.25 * (rolling_zscore(usd_inflation) or 0.0) +
    0.25 * (rolling_zscore(usd_yield) or 0.0) +
    0.15 * usd_employment
)

regime_spread_full = usd_score_full - eur_score
print(f"USD score (with labour): {usd_score_full:+.3f}")
print(f"Regime spread (full):    {regime_spread_full:+.3f}")

Bước 4: Kéo lịch sử tỷ giá giao dịch ngoại hối

Điểm số chế độ vĩ mô cung cấp sự xác định hướng, nhưng thời gian vào vẫn được hưởng lợi từ bộ lọc dựa trên giá. Nhập EUR / USD ngắn trong chế độ USD mạnh khi cặp tiền là 3 độ lệch chuẩn trên mức trung bình 50 ngày là một hồ sơ rủi ro khác với việc nhập khi nó đã có xu hướng giảm. điểm cuối ngoại hối cung cấp tỷ lệ đóng cửa hàng ngày mà bạn có thể sử dụng để tính toán bối cảnh giá cơ bản.

def fetch_spot_rates(base: str, quote: str, lookback_days: int = 200) -> pd.Series:
    """Fetch FX spot rate history and return as a date-indexed Series."""
    start = (date.today() - timedelta(days=lookback_days)).isoformat()
    resp = requests.get(
        f"{BASE_URL}/forex/{base}/{quote}",
        params={"api_key": API_KEY, "start": start},
        timeout=10,
    )
    resp.raise_for_status()
    data = resp.json().get("data", [])
    if not data:
        return pd.Series(dtype=float)
    df = pd.DataFrame(data).set_index("date").sort_index()
    return df["close"].astype(float)


spot = fetch_spot_rates("EUR", "USD")
sma50  = spot.rolling(50).mean()
sma200 = spot.rolling(200).mean()

latest_price  = spot.iloc[-1]
latest_sma50  = sma50.iloc[-1]
latest_sma200 = sma200.iloc[-1]

# Simple trend filter: is price above or below key moving averages?
price_trend = "bullish" if latest_price > latest_sma50 > latest_sma200 else (
              "bearish" if latest_price < latest_sma50 < latest_sma200 else "mixed")

print(f"EUR/USD latest: {latest_price:.5f}  SMA50: {latest_sma50:.5f}  SMA200: {latest_sma200:.5f}")
print(f"Price trend: {price_trend}")

Bước 5: Đăng ký vào Lịch phát hành

Thời gian nguy hiểm nhất để giữ một vị trí FX mở là 15 phút xung quanh một bản phát hành lớn theo lịch trình. Quyết định về tỷ lệ chính sách, bản in CPI và dữ liệu lương đều mang tiềm năng khoảng cách 3080 pip. Một algorithm có kỷ luật tốt tránh nhập các vị trí mới trong các cửa sổ này và có thể tùy chọn đóng hoặc bảo hiểm các vị thế hiện có.

Điểm cuối lịch phát hành FXMacroData trả về mỗi bản phát hành sắp tới theo lịch trình với tên chỉ số và ngày thông báo dự kiến của nó, giúp dễ dàng xây dựng một trình lên lịch tắt:

from datetime import datetime, timezone

def fetch_upcoming_releases(currency: str, days_ahead: int = 14) -> list[dict]:
    """Return scheduled macro releases for a currency over the next N days."""
    resp = requests.get(
        f"{BASE_URL}/calendar/{currency}",
        params={"api_key": API_KEY},
        timeout=10,
    )
    resp.raise_for_status()
    events = resp.json().get("data", [])
    cutoff = datetime.now(timezone.utc) + timedelta(days=days_ahead)
    upcoming = []
    for evt in events:
        dt_str = evt.get("announcement_datetime") or evt.get("date")
        if not dt_str:
            continue
        try:
            evt_dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        except ValueError:
            continue
        if datetime.now(timezone.utc) <= evt_dt <= cutoff:
            upcoming.append(evt)
    return upcoming


HIGH_IMPACT = {"policy_rate", "inflation", "non_farm_payrolls", "unemployment", "gdp"}
BLACKOUT_MINUTES = 20  # minutes before/after release to block new entries


def is_in_blackout_window(releases: list[dict], now: datetime | None = None) -> bool:
    """Return True if the current moment falls inside any high-impact release window."""
    if now is None:
        now = datetime.now(timezone.utc)
    window = timedelta(minutes=BLACKOUT_MINUTES)
    for evt in releases:
        if evt.get("indicator") not in HIGH_IMPACT:
            continue
        dt_str = evt.get("announcement_datetime") or evt.get("date")
        if not dt_str:
            continue
        try:
            evt_dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        except ValueError:
            continue
        if abs(now - evt_dt) <= window:
            return True
    return False


usd_releases = fetch_upcoming_releases("usd")
eur_releases = fetch_upcoming_releases("eur")
all_releases = usd_releases + eur_releases

print(f"Upcoming high-impact releases (next 14 days): {len(all_releases)}")
print(f"Currently in blackout window: {is_in_blackout_window(all_releases)}")

Bước 6: tạo ra tín hiệu trực tiếp

Với điểm số macro, bối cảnh tỷ giá tại chỗ, và kiểm tra mất điện theo lịch, bạn có thể lắp ráp chúng thành một chức năng tín hiệu duy nhất tạo ra hướng, độ tin cậy và kích thước vị trí được đề nghị theo yêu cầu.

from dataclasses import dataclass
from typing import Literal


@dataclass
class Signal:
    direction: Literal["long", "short", "neutral"]
    confidence: float        # 0.0 → 1.0
    regime_spread: float     # positive → USD stronger
    price_trend: str
    in_blackout: bool
    reason: str


REGIME_THRESHOLD = 0.45   # minimum spread magnitude to take a position
TREND_CONFIRMATION = True  # require price trend to agree with regime signal


def generate_signal(
    regime_spread: float,
    price_trend:   str,
    releases:      list[dict],
) -> Signal:
    """
    Combine macro regime spread and price trend into a trade signal.

    regime_spread > 0  → USD stronger → short EUR/USD (quote currency up)
    regime_spread < 0  → EUR stronger → long  EUR/USD (base currency up)
    """
    in_blackout = is_in_blackout_window(releases)

    if in_blackout:
        return Signal("neutral", 0.0, regime_spread, price_trend, True,
                      "Blackout window: high-impact release imminent.")

    magnitude = abs(regime_spread)

    if magnitude < REGIME_THRESHOLD:
        return Signal("neutral", 0.0, regime_spread, price_trend, False,
                      f"Regime spread {regime_spread:+.3f} below threshold {REGIME_THRESHOLD}.")

    # Determine raw macro direction
    macro_dir = "short" if regime_spread > 0 else "long"

    # Price trend confirmation
    if TREND_CONFIRMATION:
        if macro_dir == "short" and price_trend == "bullish":
            return Signal("neutral", 0.20, regime_spread, price_trend, False,
                          "Macro bearish EUR/USD but price trend still bullish — wait for confirmation.")
        if macro_dir == "long" and price_trend == "bearish":
            return Signal("neutral", 0.20, regime_spread, price_trend, False,
                          "Macro bullish EUR/USD but price trend still bearish — wait for confirmation.")

    # Confidence scales with regime magnitude (capped at 0.90)
    confidence = min(0.90, magnitude / 1.5)

    return Signal(macro_dir, confidence, regime_spread, price_trend, False,
                  f"Macro {'USD' if macro_dir == 'short' else 'EUR'} outperformance confirmed by price trend.")


signal = generate_signal(regime_spread_full, price_trend, all_releases)
print(f"Signal: {signal.direction.upper()}  confidence: {signal.confidence:.0%}")
print(f"Reason: {signal.reason}")

Bước 7: Áp dụng kiểm soát rủi ro và kích thước các vị trí

Việc tạo tín hiệu chỉ là một nửa công việc. Nếu không có kiểm soát rủi ro có hệ thống, ngay cả một nguồn tín hiệu chất lượng cao cũng sẽ tạo ra các khoản rút vượt quá những gì chiến lược có thể duy trì. Ba điều khiển là tối thiểu: kích thước vị trí tối đa tương đối với vốn chủ sở hữu tài khoản, một mức dừng lỗ cứng trong pips và giới hạn mất mát hàng ngày tạm dừng giao dịch sau một loạt các phiên thua lỗ.

@dataclass
class RiskConfig:
    account_equity:      float = 10_000.0   # USD
    risk_per_trade_pct:  float = 1.0        # percent of equity risked per trade
    stop_loss_pips:      float = 30.0       # maximum allowed loss in pips
    pip_value_per_lot:   float = 10.0       # USD per pip per standard lot (EUR/USD)
    max_lots:            float = 2.0        # hard cap on position size
    daily_loss_limit_pct: float = 3.0       # pause trading if daily loss exceeds this


def compute_position_size(signal: Signal, config: RiskConfig) -> float:
    """
    Return lot size based on risk per trade and stop-loss.
    Scales with signal confidence — higher confidence allows up to full risk.
    """
    if signal.direction == "neutral":
        return 0.0

    risk_amount = config.account_equity * (config.risk_per_trade_pct / 100)
    # Scale risk by confidence
    adjusted_risk = risk_amount * signal.confidence
    # Max loss per lot at this stop = stop_loss_pips * pip_value_per_lot
    max_loss_per_lot = config.stop_loss_pips * config.pip_value_per_lot
    if max_loss_per_lot == 0:
        return 0.0
    raw_lots = adjusted_risk / max_loss_per_lot
    return round(min(raw_lots, config.max_lots), 2)


risk   = RiskConfig()
lots   = compute_position_size(signal, risk)
dollar_risk = lots * risk.stop_loss_pips * risk.pip_value_per_lot

print(f"Recommended position: {lots} lots  ({signal.direction.upper()} EUR/USD)")
print(f"Max risk at {risk.stop_loss_pips}-pip stop: ${dollar_risk:.2f}")

Bước 8: Kết hợp tất cả Chuỗi chiến lược hàng ngày

Trong môi trường trực tiếp, bạn sẽ kết nối đầu ra với một API môi giới hoặc hệ thống giao dịch giấy; ở đây chúng tôi giữ nó không liên quan đến môi giới và đăng quyết định vào máy chơi.

import logging
from datetime import date, datetime, timedelta, timezone

logging.basicConfig(level=logging.INFO, format="%(asctime)s  %(message)s")
log = logging.getLogger(__name__)


def run_daily_strategy():
    """Main strategy loop — call once per trading day."""
    log.info("─── Daily macro strategy update ───")

    # 1. Fetch macro data
    log.info("Fetching macro indicators...")
    usd_rate_data  = fetch_indicator("usd", "policy_rate")
    eur_rate_data  = fetch_indicator("eur", "policy_rate")
    usd_inf_data   = fetch_indicator("usd", "inflation")
    eur_inf_data   = fetch_indicator("eur", "inflation")
    usd_nfp_data   = fetch_indicator("usd", "non_farm_payrolls")
    usd_unemp_data = fetch_indicator("usd", "unemployment")
    usd_bond_data  = fetch_indicator("usd", "gov_bond_10y")
    eur_bond_data  = fetch_indicator("eur", "gov_bond_10y")

    # 2. Compute regime scores
    usd_emp    = employment_score(usd_nfp_data, usd_unemp_data)
    usd_s      = (
        0.35 * (rolling_zscore(usd_rate_data) or 0.0) +
        0.25 * (rolling_zscore(usd_inf_data) or 0.0) +
        0.25 * (rolling_zscore(usd_bond_data) or 0.0) +
        0.15 * usd_emp
    )
    eur_s = macro_score(eur_rate_data, eur_inf_data, eur_bond_data)
    spread = usd_s - eur_s
    log.info(f"USD score: {usd_s:+.3f}  EUR score: {eur_s:+.3f}  Spread: {spread:+.3f}")

    # 3. Fetch spot rates and compute trend
    log.info("Fetching spot rates...")
    spot_series = fetch_spot_rates("EUR", "USD")
    sma50_val   = spot_series.rolling(50).mean().iloc[-1] if len(spot_series) >= 50 else None
    sma200_val  = spot_series.rolling(200).mean().iloc[-1] if len(spot_series) >= 200 else None
    last_price  = spot_series.iloc[-1]
    trend = "mixed"
    if sma50_val and sma200_val:
        trend = ("bullish" if last_price > sma50_val > sma200_val else
                 "bearish" if last_price < sma50_val < sma200_val else "mixed")
    log.info(f"EUR/USD {last_price:.5f}  trend: {trend}")

    # 4. Fetch release calendar
    log.info("Fetching release calendars...")
    releases = fetch_upcoming_releases("usd") + fetch_upcoming_releases("eur")
    log.info(f"Upcoming events: {len(releases)}")

    # 5. Generate signal
    sig  = generate_signal(spread, trend, releases)
    lots = compute_position_size(sig, RiskConfig())
    log.info(f"Signal: {sig.direction.upper()}  confidence: {sig.confidence:.0%}  lots: {lots}")
    log.info(f"Reason: {sig.reason}")

    return sig, lots


if __name__ == "__main__":
    run_daily_strategy()

Bước tiếp theo: Mở rộng chiến lược

Khung trên là cố tình mỏng để bạn có thể theo dõi mọi quyết định từ dữ liệu thô đến đầu ra cuối cùng.

• Thêm thêm tiền tệ mở rộng sang GBP, AUD, JPY hoặc CAD bằng cách sử dụng cùng một điểm cuối chỉ số. Lãi suất chính sách GBP và Lạm phát AUD chuỗi theo cùng một hợp đồng dữ liệu.
• Thêm dữ liệu định vị COT định vị đầu cơ lớn từ báo cáo CFTC COT là một bộ lọc tâm lý hữu ích. Khi chế độ macro nói dài USD nhưng dài đầu cơ đã cực đoan, rủi ro / phần thưởng của một mục nhập mới thấp hơn. FXMacroData cung cấp dữ liệu COT thông qua cùng một API.
• Kiểm tra ngược với dữ liệu thông báo lịch sử bởi vì mọi quan sát FXMacroData mang một announcement_datetime chính xác đến giây, bạn có thể tái tạo chính xác những gì thị trường biết tại bất kỳ thời điểm nào và mô phỏng các mục nhập chiến lược mà không có sự thiên vị của người xem.
• Tự động hóa bằng trình lập lịch gói run_daily_strategy() trong một công việc cron hoặc chức năng đám mây. tín hiệu macro điển hình chỉ cần cập nhật sau khi phát hành dữ liệu lớn, vì vậy cập nhật hàng ngày hoặc thậm chí hàng tuần là đủ cho các vị trí trung hạn.
• Kết nối với API môi giới tín hiệu và số lượng lô là không có môi giới. direction và lots để giao dịch lệnh trong lớp thực thi ưa thích của bạn (OANDA v20, Interactive Brokers TWS, hoặc mô phỏng giao dịch giấy).

Tóm lại

Các tín hiệu macro không phải là trang trí cho một algo chúng là cạnh.

1. Nhặt lãi suất chính sách, lạm phát, việc làm và lợi nhuận trái phiếu từ FXMacroData API với một mô hình nhất quán
2. Tính toán điểm chế độ tổng hợp cho mỗi loại tiền tệ bằng cách sử dụng bình thường hóa điểm Z và kết hợp các chỉ số cân nhắc
3. Thêm bộ lọc xu hướng giá từ lịch sử tỷ giá giao ngay FX để yêu cầu thỏa thuận vĩ mô và kỹ thuật trước khi nhập
4. Sử dụng lịch phát hành để tránh tiếng ồn của cửa sổ dữ liệu có tác động cao với một trình lên lịch tắt đơn giản
5. Kích thước các vị trí theo tỷ lệ tin cậy tín hiệu và vốn hóa tài khoản bằng mô hình rủi ro cố định phân số
6. Thêm tất cả các thành phần vào một vòng lặp hàng ngày lặp lại duy nhất

Nguồn dữ liệu đầy đủ đủ để thích nghi trong một phiên duy nhất. Lớp dữ liệu FXMacroData có cấu trúc nhất quán, loạt thông báo chính xác thời gian làm việc nặng nề để giữ cho mọi tín hiệu được căn cứ vào các sự kiện thị trường có thể xác minh.