API Services

token = auth.authenticate(otp="<OTP>")
print(f"Expires at: {token.expires_at}")

# Trả về OTPResponse(message, transaction_id)
# transaction_id là None khi OTP gửi qua SMS/email
otp = auth.request_otp_typed()

# Bản cũ: trả về dict thô của server
raw = auth.request_otp()

auth.ensure_authenticated(transaction_id=otp.transaction_id)

token = auth.refresh()

access_token = auth.ensure_authenticated(
    otp=None, transaction_id=None, poll_interval_ms=None, poll_max_retries=None,
)

accounts = trading.account.get_account_info()

for acc in accounts:
    print(f"{acc.account_no} - {acc.account_type}")

ohlc = data.market_data.get_ohlc_1minute("SSI")
for candle in ohlc:
    print(f"{candle.trading_date}: O={candle.open_price} H={candle.high_price} L={candle.low_price} C={candle.close_price} V={candle.volume}")

ohlc = data.market_data.get_ohlc_1day_historical(
    symbol="SSI",
    from_date="2026/03/27 00:00:00",
    to_date="2026/03/27 00:00:00",
    page=1,
    size=100,
)

from ssi_sdk.enums import Timeframe

# Mặc định from_date/to_date là hôm nay
bars = data.market_data.get_ohlc_all("SSI", Timeframe.MINUTE_5, ascending=True)

for bar in data.market_data.iter_ohlc("SSI", Timeframe.DAY_1, "2026/01/01", "2026/03/31"):
    print(bar.trading_date, bar.close_price)

# Tất cả chỉ số
indices = data.market_data.get_indexes()

# Theo sàn
from ssi_sdk.enums import Board
indices = data.market_data.get_indexes_by_board(Board.HOSE)

for idx in indices:
    print(f"{idx.index} - {idx.index_name}")

# Summary hiện tại
summary = data.market_data.get_index_summary("VNINDEX")

# Summary lịch sử
summary = data.market_data.get_index_summary_historical("VNINDEX", "2025/01/15")

# Summary theo sàn
summary = data.market_data.get_board_summary(Board.HOSE)

# Summary sàn lịch sử
summary = data.market_data.get_board_summary_historical(Board.HOSE, "2025/01/15")

# 1 mã
info = data.market_data.get_securities_info("SSI")

# Theo chỉ số
securities = data.market_data.get_securities_info_by_index("VN30")

# Theo sàn
securities = data.market_data.get_securities_info_by_board(Board.HOSE)

# Summary hiện tại
summary = data.market_data.get_securities_summary("SSI")

# Summary lịch sử
summary = data.market_data.get_securities_summary_historical(
    symbol="SSI",
    from_date="2025/01/01",
    to_date="2025/01/31",
)

# Summary theo chỉ số
summary = data.market_data.get_securities_summary_by_index("VN30")

# Summary theo chỉ số lịch sử
summary = data.market_data.get_securities_summary_by_index_historical(
    index="VN30",
    from_date="2025/01/01",
    to_date="2025/01/31",
)

today = data.market_data.get_master_data()
history = data.market_data.get_master_data_historical("2026/03/01", "2026/03/05")

for m in today[:3]:
    print(m.board, m.symbol, m.ceiling, m.floor, m.ref_price)

# Hôm nay (mọi mã, hoặc một mã)
today = data.market_data.get_corporate_actions()
ssi_today = data.market_data.get_corporate_actions(symbol="SSI", language="en")

# Quá khứ: khoảng ngày tối đa 5 ngày
past = data.market_data.get_corporate_actions_historical(
    from_date="2026/10/08",
    to_date="2026/10/12",
    symbol=None,     # None = tất cả mã
    language="vn",   # "vn" (mặc định) hoặc "en"
)
for e in past:
    print(e.symbol, e.event_title, e.exright_date, e.record_date, e.issue_date, e.exchange, e.ratio)

# Số dư cơ sở
equity_balance = trading.portfolio.get_equity_balance("<EQUITY_ACCOUNT_NO>")
if equity_balance:
    print(f"Account balance: {equity_balance.account_balance}")

# Số dư phái sinh
derivative_balance = trading.portfolio.get_derivative_balance("<DERIVATIVE_ACCOUNT_NO>")
if derivative_balance:
    print(f"Withdrawable: {derivative_balance.withdrawable}")

# Vị thế cơ sở: None khi không có vị thế
positions = trading.portfolio.get_equity_positions("<EQUITY_ACCOUNT_NO>") or []
for pos in positions:
    print(f"{pos.symbol}: {pos.quantity} cp | Giá vốn: {pos.cost_price}")

# Vị thế phái sinh (tất cả)
derivative_positions = trading.portfolio.get_derivative_positions("<DERIVATIVE_ACCOUNT_NO>")

# Chỉ vị thế mở phái sinh
open_pos = trading.portfolio.get_open_derivative_positions("<DERIVATIVE_ACCOUNT_NO>")

# Chỉ vị thế đóng phái sinh
closed_pos = trading.portfolio.get_closed_derivative_positions("<DERIVATIVE_ACCOUNT_NO>")

# Lệnh trong ngày
today_orders = trading.portfolio.get_today_orders("<EQUITY_ACCOUNT_NO>")
for order in today_orders:
    print(f"{order.order_id}: {order.symbol} {order.side} {order.quantity}@{order.price} - {order.status}")

# Lệnh lịch sử
historical_orders = trading.portfolio.get_historical_orders(
    "<EQUITY_ACCOUNT_NO>",
    from_date="2025/01/01",
    to_date="2025/01/31",
)

# PPMMR cơ sở
equity_ppmmr = trading.portfolio.get_equity_ppmmr("<EQUITY_ACCOUNT_NO>")
if equity_ppmmr:
    print(f"Purchasing power: {equity_ppmmr.purchasing_power}")

# PPMMR phái sinh
derivative_ppmmr = trading.portfolio.get_derivative_ppmmr("<DERIVATIVE_ACCOUNT_NO>")

from ssi_sdk.enums import OrderSide, OrderType

# Lệnh giới hạn (LO)
result = trading.trading.place_limit_order(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    price=66000,
)
print(f"Order ID: {result.order_id}, Status: {result.status}")

# Lệnh thị trường (MTL)
result = trading.trading.place_market_order(
    account_no="<ACCOUNT_NO>", symbol="SSI", side=OrderSide.BUY, quantity=100,
)

# Lệnh ATO (mở cửa)
result = trading.trading.place_ato_order(
    account_no="<ACCOUNT_NO>", symbol="SSI", side=OrderSide.BUY, quantity=100,
)

# Lệnh ATC (đóng cửa)
result = trading.trading.place_atc_order(
    account_no="<ACCOUNT_NO>", symbol="SSI", side=OrderSide.SELL, quantity=100,
)

# Lệnh tuỳ chỉnh
result = trading.trading.place_order(
    account_no="<ACCOUNT_NO>", symbol="SSI", side=OrderSide.BUY,
    quantity=100, price=66000, order_type=OrderType.LO,
)

# Sửa giá theo client_request_id
result = trading.trading.modify_order_price(
    account_no="<ACCOUNT_NO>", client_request_id="REQ123", price=68000,
)

# Sửa giá theo order_id
result = trading.trading.modify_order_price_by_order_id(
    account_no="<ACCOUNT_NO>", order_id="ORD123", price=68000,
)

# Sửa số lượng theo client_request_id
result = trading.trading.modify_order_quantity(
    account_no="<ACCOUNT_NO>", client_request_id="REQ123", quantity=200,
)

# Sửa số lượng theo order_id
result = trading.trading.modify_order_quantity_by_order_id(
    account_no="<ACCOUNT_NO>", order_id="ORD123", quantity=200,
)

# Huỷ theo client_request_id
result = trading.trading.cancel_order(
    account_no="<ACCOUNT_NO>", client_request_id="REQ123",
)

# Huỷ theo order_id
result = trading.trading.cancel_order_by_order_id(
    account_no="<ACCOUNT_NO>", order_id="ORD123",
)

import uuid
from decimal import Decimal

from ssi_sdk import Auth, Trading, Config
from ssi_sdk.enums import OrderSide, OrderType
from ssi_sdk.exceptions import APIError, DuplicateRequestError, ValidationError
from ssi_sdk.models import BatchCancelOrderItem, BatchPlaceOrderItem

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)
ACCOUNT_NO = "<ACCOUNT_NO>"
FLOOR_PRICE = Decimal("<FLOOR_PRICE>")  # lấy từ master data (mục 3.6)

with Auth(config) as auth:
    auth.ensure_authenticated(otp="<OTP>")

    with Trading(auth) as trading:
        tag = uuid.uuid4().hex[:8]
        place_items: list[BatchPlaceOrderItem] = [
            {
                "account_no": ACCOUNT_NO,
                "symbol": "SSI",
                "side": OrderSide.BUY,
                "quantity": 100,
                "price": FLOOR_PRICE,
                "order_type": OrderType.LO,
                "client_request_id": f"bt{tag}{i:02d}",  # <= 20 ký tự
            }
            for i in range(1, 4)
        ]
        if len(place_items) > config.max_batch_orders:
            raise SystemExit(f"Tối đa {config.max_batch_orders} lệnh mỗi batch")

        try:
            response = trading.trading.place_batch_orders(place_items)
        except ValidationError as e:
            raise SystemExit(f"Batch không hợp lệ (chưa gửi gì): {e}")
        except DuplicateRequestError:
            raise SystemExit("Batch id đã dùng trong ngày (409): kiểm tra sổ lệnh trước khi gửi lại")
        except APIError as e:
            raise SystemExit(f"Server từ chối batch: code={e.code} status={e.status_code} msg={e.message}")

        placed_ok: list[str] = []
        for r in response.results:
            if r.success:
                placed_ok.append(r.order_id)
                print(f"OK   {r.client_request_id} -> orderId={r.order_id} status={r.status}")
            else:
                print(f"FAIL {r.client_request_id} -> code={r.error_code} msg={r.error_message}")

        if placed_ok:
            # Mỗi item chỉ có ĐÚNG MỘT trong order_id / client_request_id
            cancel_items: list[BatchCancelOrderItem] = [
                {"account_no": ACCOUNT_NO, "order_id": oid} for oid in placed_ok
            ]
            try:
                cancel_resp = trading.trading.cancel_batch_orders(cancel_items)
            except (ValidationError, DuplicateRequestError, APIError) as e:
                raise SystemExit(f"Hủy batch thất bại: {type(e).__name__}: {e}")
            for r in cancel_resp.results:
                state = "OK  " if r.success else "FAIL"
                print(f"{state} orderId={r.order_id} cancelId={r.client_cancel_id} status={r.status}")

import asyncio
import uuid
from decimal import Decimal

from ssi_sdk import AsyncAuth, AsyncTrading, Config
from ssi_sdk.enums import OrderSide, OrderType
from ssi_sdk.exceptions import APIError, DuplicateRequestError, ValidationError

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)
ACCOUNT_NO = "<ACCOUNT_NO>"


async def main():
    async with AsyncAuth(config) as auth:
        await auth.ensure_authenticated(otp="<OTP>")

        async with AsyncTrading(auth) as trading:
            tag = uuid.uuid4().hex[:8]
            items = [
                {
                    "account_no": ACCOUNT_NO,
                    "symbol": "SSI",
                    "side": OrderSide.BUY,
                    "quantity": 100,
                    "price": Decimal("<FLOOR_PRICE>"),
                    "order_type": OrderType.LO,
                    "client_request_id": f"bt{tag}{i:02d}",
                }
                for i in range(1, 4)
            ]
            try:
                response = await trading.trading.place_batch_orders(items)
            except ValidationError as e:
                raise SystemExit(f"Batch không hợp lệ (chưa gửi gì): {e}")
            except DuplicateRequestError:
                raise SystemExit("Batch id đã dùng trong ngày (409)")
            except APIError as e:
                raise SystemExit(f"Server từ chối batch: code={e.code} msg={e.message}")

            ok_ids = [r.order_id for r in response.results if r.success]
            for r in response.results:
                if not r.success:
                    print(f"FAIL {r.client_request_id}: {r.error_code} {r.error_message}")

            if ok_ids:
                cancel_items = [{"account_no": ACCOUNT_NO, "order_id": oid} for oid in ok_ids]
                cancel_resp = await trading.trading.cancel_batch_orders(cancel_items)
                print(f"Đã hủy: {sum(1 for r in cancel_resp.results if r.success)}/{len(cancel_items)}")


asyncio.run(main())

# Với giá cụ thể
max_bs = trading.trading.get_max_buy_sell(
    account_no="<ACCOUNT_NO>", symbol="SSI", price=66000,
)
print(f"Max buy: {max_bs.max_buy_quantity}")
print(f"Max sell: {max_bs.max_sell_quantity}")

# Với giá thị trường
max_bs = trading.trading.get_max_buy_sell_at_market_price(
    account_no="<ACCOUNT_NO>", symbol="SSI",
)

from ssi_sdk.enums import OrderSide, OrderType, FCOOperator

# Lệnh GTD (Good Till Date)
gtd_res = trading.trading.place_fco_gtd(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    price=OrderType.MTL,        # Hoặc giá số cụ thể
    price_slip=0.5,
    from_date="2026/07/21 00:00:00",
    to_date="2026/07/28 23:00:00",
)

# Lệnh Stop (dừng thị trường)
stop_res = trading.trading.place_fco_stop(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    stop_price=20000,
    operator=FCOOperator.GREATER_OR_EQUAL,
    from_date="2026/07/21 00:00:00",
    to_date="2026/07/28 23:00:00",
)

# Lệnh Stop Limit (dừng giới hạn)
stop_limit_res = trading.trading.place_fco_stop_limit(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    stop_price=20000,
    price=20500,
    price_slip=0.5,
    operator=FCOOperator.GREATER_OR_EQUAL,
    from_date="2026/07/21 00:00:00",
    to_date="2026/07/28 23:00:00",
)

# Lệnh Trailing Stop (bám sát xu hướng)
ts_res = trading.trading.place_fco_trailing_stop(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    active_price=20000,
    trailing_amount=1000,
    from_date="2026/07/21 00:00:00",
    to_date="2026/07/28 23:00:00",
)

# Lệnh OCO (huỷ lệnh kia khi 1 trong 2 khớp)
oco_res = trading.trading.place_fco_oco(
    account_no="<ACCOUNT_NO>",
    symbol="SSI",
    side=OrderSide.BUY,
    quantity=100,
    tp_active_price=30000,      # Giá kích hoạt chốt lời
    sl_active_price=20000,      # Giá kích hoạt cắt lỗ
    tp_price=OrderType.MP,
    sl_price=OrderType.MP,
    tp_slip=0.1,
    sl_slip=0,
    from_date="2026/07/21 00:00:00",
    to_date="2026/07/28 23:00:00",
)

# Huỷ lệnh điều kiện
cancel_res = trading.trading.cancel_fco(fco_id="<FCO_ID>")

# Bất đồng bộ: cú pháp await tương tự trên trading từ AsyncTrading
gtd_res = await trading.trading.place_fco_gtd(
    account_no="<ACCOUNT_NO>", symbol="SSI", side=OrderSide.BUY, quantity=100,
    price=OrderType.MTL, price_slip=0.5,
    from_date="2026/07/21 00:00:00", to_date="2026/07/28 23:00:00",
)

# Lấy toàn bộ lệnh FCO theo tài khoản
fcos = trading.trading.get_fco_by_account_no(account_no="<ACCOUNT_NO>")

# Lấy FCO theo mã chứng khoán
fcos_symbol = trading.trading.get_fco_by_symbol(account_no="<ACCOUNT_NO>", symbol="SSI")

# Lấy FCO theo trạng thái xử lý
fcos_status = trading.trading.get_fco_by_status(account_no="<ACCOUNT_NO>", process_status="TRIT")

# Lấy FCO theo khoảng thời gian (ngày trần được chấp nhận)
fcos_date = trading.trading.get_fco_by_date(account_no="<ACCOUNT_NO>", from_date="2026/07/01", to_date="2026/07/21")

# Lấy một lệnh FCO cụ thể bằng ID
fco_info = trading.trading.get_fco_by_id(account_no="<ACCOUNT_NO>", fco_id="<FCO_ID>")

# Lấy nhật ký khớp lệnh (order book) của lệnh FCO
order_book = trading.trading.get_fco_order_book(fco_id="<FCO_ID>")

# Lịch sử trạng thái của lệnh FCO (rỗng thì trả về [])
history = trading.trading.get_fco_status_history(fco_id="<FCO_ID>")
for h in history:
    print(h.state, h.time, h.code, h.detail)

stream.streaming.connect()       # Kết nối WebSocket
stream.streaming.disconnect()    # Ngắt kết nối
stream.streaming.wait(timeout_ms=None)  # Chờ nhận dữ liệu (block)

def on_market_data(msg):
    print(f"Market data: {msg}")

def on_trading_data(msg):
    print(f"Trading: {msg}")

def on_heartbeat(msg):
    print(f"Heartbeat: {msg.status}")

stream.streaming.on_data = on_market_data
stream.streaming.on_trading = on_trading_data
stream.streaming.on_heartbeat = on_heartbeat

# Tất cả kênh (trade + quote + room) cho mã
stream.streaming.subscribe_symbol(["SSI", "HPG", "VIC"])

# Từng kênh riêng
stream.streaming.subscribe_symbol_trade(["SSI", "HPG"])
stream.streaming.subscribe_symbol_quote(["SSI", "HPG"])
stream.streaming.subscribe_symbol_room(["SSI", "HPG"])
stream.streaming.subscribe_symbol_put_through(["SSI"])
stream.streaming.subscribe_symbol_odd_lot(["SSI"])

# OHLCV theo interval
from ssi_sdk.enums import Timeframe
stream.streaming.subscribe_symbol_ohlcv(["SSI"], interval=Timeframe.MINUTE_1)

# Theo sàn
from ssi_sdk.enums import Board
stream.streaming.subscribe_board([Board.HOSE, Board.HNX])

# Theo chỉ số (mã thành phần), xem 6.7
stream.streaming.subscribe_index(["VNINDEX", "VN30"])

# Thị trường
stream.streaming.subscribe_market(["HOSE"])

stream.streaming.unsubscribe_symbol(["SSI", "HPG"])
stream.streaming.unsubscribe_symbol_trade(["SSI"])
stream.streaming.unsubscribe_symbol_quote(["SSI"])
stream.streaming.unsubscribe_symbol_room(["SSI"])
stream.streaming.unsubscribe_symbol_put_through(["SSI"])
stream.streaming.unsubscribe_symbol_odd_lot(["SSI"])

# Huỷ OHLCV
stream.streaming.unsubscribe_symbol_ohlcv(["SSI"], interval=Timeframe.MINUTE_1)

stream.streaming.unsubscribe_board([Board.HOSE])
stream.streaming.unsubscribe_index(["VNINDEX"])

# Trạng thái lệnh (tất cả tài khoản)
stream.streaming.subscribe_order_status()

# Cho tài khoản cụ thể
stream.streaming.subscribe_order_status(account_no="<ACCOUNT_NO>")

# Portfolio
stream.streaming.subscribe_portfolio()
stream.streaming.subscribe_portfolio(account_no="<ACCOUNT_NO>")

# Ping một lần
stream.streaming.ping()

# Ping tự động theo chu kỳ (mili giây)
stream.streaming.ping(interval_ms=30000)

from collections import Counter

from ssi_sdk import Auth, Stream, Config
from ssi_sdk.models import IndexSummaryMessage, IndexTickMessage, MarketFlagMessage

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)
counts: Counter = Counter()


def on_connection(event):
    # state: connected | reconnected | disconnected | failed
    err = f" | lỗi: {type(event.error).__name__}" if event.error else ""
    print(f"[CONN] {event.state} (reconnect_count={event.reconnect_count}){err}")


def on_data(msg):
    counts[type(msg).__name__] += 1
    if isinstance(msg, IndexTickMessage):  # không có callback typed riêng cho tick chỉ số
        print(f"[TICK] {msg.symbol} value={msg.value} change={msg.change} change_percent={msg.change_percent}")


def on_index_summary(msg: IndexSummaryMessage):
    if counts["IndexSummary"] == 0:  # chỉ in lần đầu để xem cấu trúc
        print(f"[SUMMARY] {msg.index} | số trường: {len(msg.data)}")
    counts["IndexSummary"] += 1


def on_market_flag(msg: MarketFlagMessage):
    print(f"[FLAG] {msg.board} | {msg.flag} | {msg.trading_time}")


with Auth(config) as auth:
    auth.ensure_authenticated(otp="<OTP>")

    with Stream(auth) as stream:
        ws = stream.streaming

        # Đăng ký callback TRƯỚC khi connect
        ws.on_connection = on_connection
        ws.on_data = on_data
        ws.on_index_summary = on_index_summary
        ws.on_market_flag = on_market_flag

        ws.connect()

        ws.subscribe_index_ticks(["VNINDEX"])         # tick của chính chỉ số
        ws.subscribe_index_trade(["VN30"], interval="1m")  # nến 1 phút của VN30
        ws.subscribe_index_summary(["VN30"])          # số liệu tổng hợp
        ws.subscribe_market_flag()                    # cờ phiên
        ws.subscribe_index(["VN30"])                  # trade/quote/room của mã thành phần

        ws.wait(timeout_ms=30_000)  # nghe 30 giây

        subs = ws.list_subscription()
        print(f"data={len(subs['data'])} topic, trading={len(subs['trading'])} topic")

        ws.unsubscribe_index_ticks(["VNINDEX"])
        ws.unsubscribe_index_trade(["VN30"], interval="1m")  # cùng interval đã subscribe
        removed = ws.unsubscribe_all()  # hủy mọi thứ còn lại
        print(f"unsubscribe_all: data={len(removed['data'])}, trading={len(removed['trading'])}")

        print(dict(counts))

import asyncio

from ssi_sdk import AsyncAuth, AsyncStream, Config
from ssi_sdk.models import IndexTickMessage

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)


async def on_data(msg):  # callback có thể là coroutine
    if isinstance(msg, IndexTickMessage):
        print(f"[TICK] {msg.symbol} value={msg.value}")


async def main():
    async with AsyncAuth(config) as auth:
        await auth.ensure_authenticated(otp="<OTP>")

        async with AsyncStream(auth) as stream:
            ws = stream.streaming
            ws.on_data = on_data

            await ws.connect()
            await ws.subscribe_index_ticks(["VNINDEX"])
            await ws.subscribe_index_summary(["VN30"])

            await ws.wait(timeout_ms=30_000)

            subs = await ws.list_subscription()
            print(f"data={len(subs['data'])} topic")
            await ws.unsubscribe_all()


asyncio.run(main())

from ssi_sdk import (
    trading_ws, async_trading_ws,
    TradingWSClient, AsyncTradingWSClient,
    TradingWSResponse, TradingWSError,
)

import uuid
from decimal import Decimal

from ssi_sdk import Auth, Config, TradingWSError, trading_ws
from ssi_sdk.enums import OrderSide, OrderType
from ssi_sdk.exceptions import ValidationError, WebSocketError

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)
ACCOUNT_NO = "<ACCOUNT_NO>"


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


with Auth(config) as auth:
    auth.ensure_authenticated(otp="<OTP>")

    try:
        ws = trading_ws(auth, respect_rate_limit=True, max_rate_limit_wait_ms=2000)
    except (TradingWSError, WebSocketError) as e:
        raise SystemExit(f"Không kết nối được trading WS: {type(e).__name__}: {e}")

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

        try:
            ack = ws.place_order(
                account_no=ACCOUNT_NO,
                symbol="SSI",
                side=OrderSide.BUY,
                quantity=100,
                price=Decimal("<GIA_SAN>"),  # lệnh LO xa thị trường
                order_type=OrderType.LO,
                client_request_id=f"ws{uuid.uuid4().hex[:12]}",  # <= 20 ký tự
            )
            print(f"Ack: orderId={ack.order_id} status={ack.status}")  # thường là PD

            cancel = ws.cancel_order(account_no=ACCOUNT_NO, order_id=ack.order_id)
            print(f"Ack hủy: status={cancel.status}")
        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: status={e.status} code={e.error_code} msg={e.server_message}")

        book = ws.query_order_book(ACCOUNT_NO, symbol="SSI", page_size=10)
        print(f"query_order_book: status={book.status}")
        print("rate_limit:", ws.client.rate_limit)

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

import asyncio
import uuid
from decimal import Decimal

from ssi_sdk import AsyncAuth, Config, TradingWSError, async_trading_ws
from ssi_sdk.enums import OrderSide, OrderType

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)
ACCOUNT_NO = "<ACCOUNT_NO>"


async def on_event(frame: dict):  # có thể là hàm thường hoặc coroutine
    data = frame.get("data") if isinstance(frame.get("data"), dict) else {}
    print(f"[EVENT] {data.get('eventType')} | status={data.get('orderStatus')}")


async def main():
    async with AsyncAuth(config) as auth:
        await auth.ensure_authenticated(otp="<OTP>")

        ws = await async_trading_ws(auth)
        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="SSI",
                    side=OrderSide.BUY,
                    quantity=100,
                    price=Decimal("<GIA_SAN>"),
                    order_type=OrderType.LO,
                    client_request_id=f"ws{uuid.uuid4().hex[:12]}",
                )
                await ws.cancel_order(account_no=ACCOUNT_NO, order_id=ack.order_id)
            except TradingWSError as e:
                print(f"Server từ chối: status={e.status} code={e.error_code}")

            await ws.unsubscribe_all_events()
        finally:
            await ws.close()


asyncio.run(main())