17. Trading WebSocket

Auth (OTP) → Master data (giá sàn) → trading_ws(auth) → subscribe_order_events → place_order → cancel_order → query_position / query_order_book → close

import time
import uuid
from decimal import Decimal

from ssi_sdk import Auth, Data, Config, TradingWSError, trading_ws
from ssi_sdk.enums import OrderSide, OrderType
from ssi_sdk.exceptions import ValidationError, WebSocketError
from auth_helper import ensure_auth
from helpers import confirm_real_orders, enum_value, mask_account, require_account

config = Config(
    client_id="<your_client_id>",
    api_key="<your_api_key>",
    api_secret="<your_api_secret>",
    private_key="<your_private_key>",
)
ACCOUNT_NO = "<your_account_no>"
SYMBOL = "SSI"
QUANTITY = 100

events: list[dict] = []

def on_event(frame: dict):
    # Chỉ giữ loại sự kiện và trạng thái, không giữ topic/số tài khoản
    data = frame.get("data") if isinstance(frame.get("data"), dict) else {}
    events.append({"eventType": data.get("eventType"), "status": data.get("orderStatus")})
    print(f"  [EVENT] {data.get('eventType')} | status={data.get('orderStatus')}")

def show_rate_limit(ws, label: str):
    rl = ws.client.rate_limit
    print(f"  [RATE] {label}: limit={rl.get('limit')} remaining={rl.get('remaining')} resetMs={rl.get('resetMs')}")

require_account(ACCOUNT_NO)
confirm_real_orders(f"1 lệnh LO mua {SYMBOL} qua trading WebSocket")

with Auth(config) as auth:
    ensure_auth(auth, otp="<your_otp>")

    # Giá sàn qua REST để đặt lệnh nằm chờ, xa thị trường
    with Data(auth) as data:
        master = next((m for m in data.market_data.get_master_data() if m.symbol == SYMBOL), None)
    if master is None or master.floor <= 0:
        raise SystemExit(f"Không có giá sàn của {SYMBOL}, dừng để an toàn.")
    floor_price = Decimal(str(master.floor))

    # Bước 1: Kết nối
    try:
        ws = trading_ws(auth)  # tùy chọn: respect_rate_limit, max_rate_limit_wait_ms, request_timeout_ms...
    except (TradingWSError, WebSocketError) as e:
        raise SystemExit(f"Không kết nối được trading WS (kiểm tra scope tradingws:* và URL trading WS): {type(e).__name__}: {e}")

    try:
        # Bước 2: Nhận sự kiện lệnh
        ws.client.on_event = on_event
        ws.subscribe_order_events(ACCOUNT_NO)
        print(f"Đã subscribe sự kiện lệnh tài khoản {mask_account(ACCOUNT_NO)}")

        # Bước 3: Đặt lệnh rồi hủy
        try:
            ack = ws.place_order(
                account_no=ACCOUNT_NO,
                symbol=SYMBOL,
                side=OrderSide.BUY,
                quantity=QUANTITY,
                price=floor_price,
                order_type=OrderType.LO,
                client_request_id=f"ws{uuid.uuid4().hex[:12]}",  # <= 20 ký tự
            )
            print(f"Ack đặt lệnh: orderId={ack.order_id} status={enum_value(ack.status)} (PD = đang chờ xử lý)")
            show_rate_limit(ws, "sau place_order")

            time.sleep(2)  # chờ sự kiện lệnh về on_event
            cancel = ws.cancel_order(account_no=ACCOUNT_NO, order_id=ack.order_id)
            print(f"Ack hủy lệnh: status={enum_value(cancel.status)}")
            time.sleep(2)
        except ValidationError as e:
            print(f"Dữ liệu không hợp lệ (chưa gửi gì): {e}")
        except TradingWSError as e:
            # status: 401 token hết hạn | 403 thiếu scope | 429 hết quota | 5xx lỗi server
            print(f"Server từ chối lệnh: status={e.status} code={e.error_code} msg={e.server_message}")
            if e.status == 429:
                print("  Hết quota: chờ resetMs trong client.rate_limit rồi mới gửi tiếp.")

        # Bước 4: Truy vấn vị thế và sổ lệnh
        try:
            pos = ws.query_position(ACCOUNT_NO, query_summary=True)
            print(f"query_position: status={pos.status}")
            book = ws.query_order_book(ACCOUNT_NO, symbol=SYMBOL, page_size=10)
            print(f"query_order_book: status={book.status}")
            show_rate_limit(ws, "sau truy vấn")
        except TradingWSError as e:
            print(f"Truy vấn bị từ chối: status={e.status} code={e.error_code} msg={e.server_message}")

        print(f"Tổng số sự kiện nhận được: {len(events)}")
        ws.unsubscribe_all_events()
    finally:
        ws.close()  # luôn đóng socket

import asyncio
import uuid
from decimal import Decimal

from ssi_sdk import AsyncAuth, AsyncData, Config, TradingWSError, async_trading_ws
from ssi_sdk.enums import OrderSide, OrderType
from ssi_sdk.exceptions import ValidationError, WebSocketError
from auth_helper import ensure_auth_async
from helpers import confirm_real_orders, enum_value, require_account

config = Config(...)
ACCOUNT_NO = "<your_account_no>"
SYMBOL = "SSI"

def on_event(frame: dict):
    data = frame.get("data") if isinstance(frame.get("data"), dict) else {}
    print(f"  [EVENT] {data.get('eventType')} | status={data.get('orderStatus')}")

async def main():
    require_account(ACCOUNT_NO)
    confirm_real_orders(f"1 lệnh LO mua {SYMBOL} qua trading WebSocket")

    async with AsyncAuth(config) as auth:
        await ensure_auth_async(auth, otp="<your_otp>")

        async with AsyncData(auth) as data:
            master_data = await data.market_data.get_master_data()
        master = next((m for m in master_data if m.symbol == SYMBOL), None)
        if master is None or master.floor <= 0:
            raise SystemExit(f"Không có giá sàn của {SYMBOL}, dừng để an toàn.")
        floor_price = Decimal(str(master.floor))

        try:
            ws = await async_trading_ws(auth)
        except (TradingWSError, WebSocketError) as e:
            raise SystemExit(f"Không kết nối được trading WS (kiểm tra scope tradingws:* và URL trading WS): {type(e).__name__}: {e}")

        try:
            ws.client.on_event = on_event
            await ws.subscribe_order_events(ACCOUNT_NO)

            try:
                ack = await ws.place_order(
                    account_no=ACCOUNT_NO, symbol=SYMBOL, side=OrderSide.BUY,
                    quantity=100, price=floor_price, order_type=OrderType.LO,
                    client_request_id=f"ws{uuid.uuid4().hex[:12]}",  # <= 20 ký tự
                )
                print(f"Ack đặt lệnh: orderId={ack.order_id} status={enum_value(ack.status)}")

                await asyncio.sleep(2)  # chờ sự kiện lệnh về on_event
                cancel = await ws.cancel_order(account_no=ACCOUNT_NO, order_id=ack.order_id)
                print(f"Ack hủy lệnh: status={enum_value(cancel.status)}")
                await asyncio.sleep(2)
            except ValidationError as e:
                print(f"Dữ liệu không hợp lệ (chưa gửi gì): {e}")
            except TradingWSError as e:
                print(f"Server từ chối lệnh: status={e.status} code={e.error_code}")

            try:
                pos = await ws.query_position(ACCOUNT_NO, query_summary=True)
                book = await ws.query_order_book(ACCOUNT_NO, symbol=SYMBOL, page_size=10)
                print(f"query_position: {pos.status} | query_order_book: {book.status}")
            except TradingWSError as e:
                print(f"Truy vấn bị từ chối: status={e.status} code={e.error_code}")

            await ws.unsubscribe_all_events()
        finally:
            await ws.close()  # luôn đóng socket

asyncio.run(main())