API Services

token, err := auth.Authenticate(os.Getenv("SSI_OTP")) // YOUR_OTP
if err != nil {
    log.Fatal(err)
}
_ = token // *auth.Token; đừng in hoặc log access token

// Map thô
result, err := auth.RequestOTP()

// Response có kiểu: Message và TransactionID
otpRes, err := auth.RequestOTPTyped()

// Trả về chuỗi access token
accessToken, err := auth.EnsureAuthenticated(os.Getenv("SSI_OTP"))

// Với tuỳ chọn (chu kỳ poll và số lần thử tối đa)
interval := 5000
retries := 12
accessToken, err = auth.EnsureAuthenticatedWith(ctx, authpkg.EnsureOptions{
    OTP:            os.Getenv("SSI_OTP"),
    PollIntervalMs: &interval,
    PollMaxRetries: &retries,
})

token, err := auth.Refresh()

if auth.TokenManager.IsTokenExpired() { // lệch 30 s
    auth.Refresh()
}

accessToken := auth.AccessToken()

accounts, err := t.Account.GetAccountInfo()

for _, acc := range accounts {
    accType := "unknown"
    if acc.AccountType != nil { // con trỏ: nil khi server không gửi loại tài khoản
        accType = string(*acc.AccountType)
    }
    fmt.Printf("%s (%s)\n", acc.AccountNo, accType)
}

ohlc, err := data.MarketData.GetOHLC1Minute("SSI")
if err != nil {
    log.Fatal(err)
}
for _, candle := range ohlc {
    fmt.Printf("%s: O=%.0f H=%.0f L=%.0f C=%.0f V=%d\n",
        candle.TradingDate, candle.OpenPrice, candle.HighPrice,
        candle.LowPrice, candle.ClosePrice, candle.Volume)
}

ohlc, err := data.MarketData.GetOHLC1DayHistorical(
    "SSI", "2026/03/27", "2026/04/22", 1, 100,
)

// Tất cả chỉ số
indexes, err := data.MarketData.GetIndexes()

// Theo sàn
import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/market"
indexes, err := data.MarketData.GetIndexesByBoard(market.BoardHOSE)

for _, idx := range indexes {
    fmt.Printf("%s - %s\n", idx.Index, idx.IndexName)
}

// Tổng hợp hiện tại
summary, err := data.MarketData.GetIndexSummary("VNINDEX")

// Tổng hợp lịch sử
summary, err := data.MarketData.GetIndexSummaryHistorical("VNINDEX", "2026/01/15")

// Tổng hợp theo sàn
summary, err := data.MarketData.GetBoardSummary(market.BoardHOSE)

// Tổng hợp theo sàn lịch sử
summary, err := data.MarketData.GetBoardSummaryHistorical(market.BoardHOSE, "2026/01/15")

// Một mã
info, err := data.MarketData.GetSecuritiesInfo("SSI")
if err == nil && info == nil {
    fmt.Println("không tìm thấy mã") // nil khi không tìm thấy
}

// Theo chỉ số
securities, err := data.MarketData.GetSecuritiesInfoByIndex("VN30")

// Theo sàn
securities, err := data.MarketData.GetSecuritiesInfoByBoard(market.BoardHOSE)

// Tổng hợp hiện tại
summary, err := data.MarketData.GetSecuritiesSummary("SSI")

// Tổng hợp lịch sử
summary, err := data.MarketData.GetSecuritiesSummaryHistorical(
    "SSI", "2026/03/01", "2026/03/31",
)

// Theo chỉ số
summary, err := data.MarketData.GetSecuritiesSummaryByIndex("VN30")

// Theo chỉ số lịch sử
summary, err := data.MarketData.GetSecuritiesSummaryByIndexHistorical(
    "VN30", "2026/03/01", "2026/03/31",
)

// Master data hiện tại
master, err := data.MarketData.GetMasterData()

// Master data lịch sử
master, err = data.MarketData.GetMasterDataHistorical("2026/03/01", "2026/03/31")

import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/market"

// Hôm nay, tất cả mã (ngôn ngữ "vn")
actions, err := data.MarketData.GetCorporateActions()

// Một mã, nội dung sự kiện tiếng Anh
actions, err = data.MarketData.GetCorporateActions(
    market.WithCorporateActionsSymbol("SSI"),
    market.WithCorporateActionsLanguage("en"), // "vn" (mặc định) hoặc "en"
)

// Khoảng ngày trong quá khứ (tối đa 5 ngày)
hist, err := data.MarketData.GetCorporateActionsHistorical(
    "2026/10/19", "2026/10/24",
    market.WithCorporateActionsSymbol("SSI"),
)

for _, a := range hist {
    fmt.Printf("%s %s: ex-right=%s record=%s ratio=%s\n",
        a.Symbol, a.EventTitle, a.ExrightDate, a.RecordDate, a.Ratio)
}

// Số dư cổ phiếu
balance, err := t.Portfolio.GetEquityBalance("YOUR_ACCOUNT_NO")
if err == nil && balance != nil {
    fmt.Printf("Withdrawable: %.0f\n", balance.Withdrawable)
}

// Số dư phái sinh
derBalance, err := t.Portfolio.GetDerivativeBalance("YOUR_DERIVATIVE_ACCOUNT_NO")

// Vị thế cổ phiếu
positions, err := t.Portfolio.GetEquityPositions("YOUR_ACCOUNT_NO")
for _, pos := range positions { // nil khi rỗng
    fmt.Printf("%s: %d cổ | Giá vốn: %.0f\n", pos.Symbol, pos.Quantity, pos.CostPrice)
}

// Tất cả vị thế phái sinh (*AllDerivativePosition)
derPositions, err := t.Portfolio.GetDerivativePositions("YOUR_DERIVATIVE_ACCOUNT_NO")

// Chỉ vị thế đang mở
openPos, err := t.Portfolio.GetOpenDerivativePositions("YOUR_DERIVATIVE_ACCOUNT_NO")

// Chỉ vị thế đã đóng
closedPos, err := t.Portfolio.GetClosedDerivativePositions("YOUR_DERIVATIVE_ACCOUNT_NO")

// Lệnh trong ngày
orders, err := t.Portfolio.GetTodayOrders("YOUR_ACCOUNT_NO")
for _, order := range orders {
    fmt.Printf("%s: %s %s %d@%.0f - %s\n",
        order.OrderID, order.Symbol, order.Side, order.Quantity, order.Price, order.Status)
}

// Lệnh lịch sử
orders, err = t.Portfolio.GetHistoricalOrders("YOUR_ACCOUNT_NO", "2026/01/01", "2026/01/31")

// PPMMR cổ phiếu
ppmmr, err := t.Portfolio.GetEquityPPMMR("YOUR_ACCOUNT_NO")

// PPMMR phái sinh
derPPMMR, err := t.Portfolio.GetDerivativePPMMR("YOUR_DERIVATIVE_ACCOUNT_NO")

import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/trading"

accountNo := "YOUR_ACCOUNT_NO"

// Lệnh giới hạn (LO)
result, err := t.Trading.PlaceLimitOrder(accountNo, "SSI", trading.OrderSideBuy, 100, 66000)

// Lệnh thị trường (MTL)
result, err = t.Trading.PlaceMarketOrder(accountNo, "SSI", trading.OrderSideBuy, 100)

// Lệnh ATO (mở cửa)
result, err = t.Trading.PlaceATOOrder(accountNo, "SSI", trading.OrderSideBuy, 100)

// Lệnh ATC (đóng cửa)
result, err = t.Trading.PlaceATCOrder(accountNo, "SSI", trading.OrderSideSell, 100)

// Loại lệnh tuỳ chỉnh
result, err = t.Trading.PlaceOrder(
    accountNo, "SSI", trading.OrderSideBuy, 100, 66000, trading.OrderTypeLO,
)

// Idempotency key do bạn tự đặt (tối đa 20 ký tự)
result, err = t.Trading.PlaceLimitOrder(accountNo, "SSI", trading.OrderSideBuy, 100, 66000,
    trading.WithClientRequestID("YOUR_CLIENT_REQUEST_ID"))

fmt.Printf("Order ID: %s, Status: %s\n", result.OrderID, result.Status)

// Sửa giá theo client_request_id
result, err := t.Trading.ModifyOrderPrice(accountNo, "YOUR_CLIENT_REQUEST_ID", 68000)

// Sửa giá theo order_id
result, err = t.Trading.ModifyOrderPriceByOrderID(accountNo, "YOUR_ORDER_ID", 68000)

// Sửa khối lượng theo client_request_id
result, err = t.Trading.ModifyOrderQuantity(accountNo, "YOUR_CLIENT_REQUEST_ID", 200)

// Sửa khối lượng theo order_id
result, err = t.Trading.ModifyOrderQuantityByOrderID(accountNo, "YOUR_ORDER_ID", 200)

// Huỷ theo client_request_id
result, err := t.Trading.CancelOrder(accountNo, "YOUR_CLIENT_REQUEST_ID")

// Huỷ theo order_id
result, err = t.Trading.CancelOrderByOrderID(accountNo, "YOUR_ORDER_ID")

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/ssi"
    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/trading"
)

func main() {
    config := ssi.NewConfig(os.Getenv("SSI_CLIENT_ID"))
    config.APIKey = os.Getenv("SSI_API_KEY")
    config.APISecret = os.Getenv("SSI_API_SECRET")
    config.PrivateKey = os.Getenv("SSI_PRIVATE_KEY") // bắt buộc để ký lệnh

    a := ssi.NewAuth(config)
    defer a.Close()
    if _, err := a.Authenticate(os.Getenv("SSI_OTP")); err != nil {
        log.Fatalf("Authenticate: %v", err)
    }

    t := ssi.NewTrading(a)

    accountNo := "YOUR_ACCOUNT_NO"
    items := []trading.BatchPlaceOrderItem{
        {
            AccountNo:       accountNo,
            Symbol:          "SSI",
            Side:            trading.OrderSideBuy,
            Quantity:        100,
            Price:           25000, // thay bằng giá hợp lệ theo bước giá
            OrderType:       trading.OrderTypeLO,
            ClientRequestID: "BATCH-0001", // <= 20 ký tự; để trống thì SDK tự sinh
        },
        {
            AccountNo:       accountNo,
            Symbol:          "HPG",
            Side:            trading.OrderSideBuy,
            Quantity:        200,
            Price:           26000,
            OrderType:       trading.OrderTypeLO,
            ClientRequestID: "BATCH-0002",
        },
    }

    res, err := t.Trading.PlaceBatchOrders(items)
    if err != nil {
        log.Fatalf("PlaceBatchOrders: %v", err) // phân loại bằng reportBatchError bên dưới
    }

    fmt.Printf("BatchRequestID: %s\n", res.BatchRequestID)
    for i, r := range res.Results {
        if r.Success {
            fmt.Printf("#%d OK   | %s | OrderID: %s | Status: %s\n",
                i+1, r.ClientRequestID, r.OrderID, r.Status)
        } else {
            fmt.Printf("#%d FAIL | %s | %s: %s\n",
                i+1, r.ClientRequestID, r.ErrorCode, r.ErrorMessage)
        }
    }
}

cancels := []trading.BatchCancelOrderItem{
    {AccountNo: accountNo, ClientRequestID: "BATCH-0001"}, // huỷ theo id bạn đặt
    {AccountNo: accountNo, OrderID: "YOUR_ORDER_ID"},      // huỷ theo id server cấp
}

cres, err := t.Trading.CancelBatchOrders(cancels)
if err != nil {
    log.Printf("CancelBatchOrders: %v", err)
    // Chưa chắc lệnh nào đã huỷ: kiểm tra trạng thái lệnh trước khi làm gì tiếp.
    return
}
for i, r := range cres.Results {
    fmt.Printf("#%d success=%v | Status: %s | %s %s\n",
        i+1, r.Success, r.Status, r.ErrorCode, r.ErrorMessage)
}

import (
    "errors"
    "fmt"

    ssisdk "github.com/SSI-Securities-Inc/ssi-sdk-go/v3"
)

func reportBatchError(op string, err error) {
    var dup *ssisdk.DuplicateRequestError
    var vErr *ssisdk.ValidationError
    var rl *ssisdk.RateLimitError

    switch {
    case errors.As(err, &dup):
        // HTTP 409: ClientRequestID hoặc BatchRequestID đã dùng trong ngày.
        fmt.Printf("%s: trùng id (409): %v\n", op, dup)
    case errors.As(err, &vErr):
        // Lỗi cục bộ: cả lô bị từ chối, chưa gửi gì lên server.
        fmt.Printf("%s: dữ liệu không hợp lệ: %v\n", op, vErr)
    case errors.As(err, &rl):
        wait := "không rõ"
        if rl.RetryAfterMs != nil {
            wait = fmt.Sprintf("%d ms", *rl.RetryAfterMs)
        }
        fmt.Printf("%s: bị giới hạn tốc độ, thử lại sau %s\n", op, wait)
    default:
        fmt.Printf("%s: lỗi: %v\n", op, err)
    }
}

// Với giá cụ thể
price := 66000.0
maxBS, err := t.Trading.GetMaxBuySell(accountNo, "SSI", &price)
fmt.Printf("Max mua: %d, Max bán: %d\n", maxBS.MaxBuyQuantity, maxBS.MaxSellQuantity)

// Theo giá thị trường
maxBS, err = t.Trading.GetMaxBuySellAtMarketPrice(accountNo, "SSI")

import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/trading"

accountNo := "YOUR_ACCOUNT_NO"
fromDate := "2026/07/01 00:00:00"
toDate := "2026/07/21 23:59:59"

// 1. Đặt lệnh GTD (Good Till Date)
gtd, err := t.Trading.PlaceFcoGtd(
    accountNo, "SSI", trading.OrderSideBuy, 100, 25000, 500, fromDate, toDate,
)

// 2. Đặt lệnh Stop Market
stop, err := t.Trading.PlaceFcoStop(
    accountNo, "SSI", trading.OrderSideSell, 100, 24000, trading.FCOOperatorLesserOrEqual, fromDate, toDate,
)

// 3. Đặt lệnh Stop Limit
stopLimit, err := t.Trading.PlaceFcoStopLimit(
    accountNo, "SSI", trading.OrderSideBuy, 100, 25500, 500, 25000, trading.FCOOperatorGreaterOrEqual, fromDate, toDate,
)

// 4. Đặt lệnh Trailing Stop
trailing, err := t.Trading.PlaceFcoTrailingStop(
    accountNo, "SSI", trading.OrderSideBuy, 100, 26000, 1000, fromDate, toDate,
)

// 5. Đặt lệnh Trailing Stop Limit
trailingLimit, err := t.Trading.PlaceFcoTrailingStopLimit(
    accountNo, "SSI", trading.OrderSideBuy, 100, 26000, 1000, 500, fromDate, toDate,
)

// 6. Đặt lệnh OCO (One-Cancels-the-Other)
oco, err := t.Trading.PlaceFcoOco(
    accountNo, "SSI", trading.OrderSideSell, 100, 30000, 24000, trading.OrderTypeMTL, trading.OrderTypeMTL, 500, 500, fromDate, toDate,
)

// 7. Đặt lệnh Bull Bear
bullBear, err := t.Trading.PlaceFcoBullBear(
    accountNo, "SSI", trading.OrderSideBuy, 1000, 100.5, 10, 30, 20, 30, 10, 0.1, 0, fromDate, toDate,
)

// Hủy lệnh FCO
cancelRes, err := t.Trading.CancelFco(gtd.FCOID)

cancelRes, err = t.Trading.CancelFco(gtd.FCOID, trading.WithOTPCode(os.Getenv("SSI_FCO_OTP")))

// Tra cứu danh sách lệnh FCO theo tài khoản
fcoList, err := t.Trading.GetFcoByAccountNo(accountNo, 1, 10)

// Tra cứu theo mã chứng khoán
fcoList, err = t.Trading.GetFcoBySymbol(accountNo, "SSI", 1, 10)

// Tra cứu theo trạng thái xử lý
fcoList, err = t.Trading.GetFcoByStatus(accountNo, trading.FCOStatusTrit, 1, 10)

// Tra cứu theo một trong nhiều trạng thái
fcoList, err = t.Trading.GetFcoByStatuses(accountNo,
    []trading.FCOStatus{trading.FCOStatusWait, trading.FCOStatusTri}, 1, 10)

// Tra cứu theo khoảng ngày
fcoList, err = t.Trading.GetFcoByDate(accountNo, "2026/07/01", "2026/07/21", 1, 10)

// Lấy một lệnh FCO cụ thể theo ID
fcoInfo, err := t.Trading.GetFcoById(accountNo, "YOUR_FCO_ID")

// Lấy nhật ký khớp lệnh (order book) của lệnh FCO
orderBook, err := t.Trading.GetFcoOrderBook("YOUR_FCO_ID", 1, 10)

// Lấy các lần chuyển trạng thái của lệnh FCO
history, err := t.Trading.GetFcoStatusHistory("YOUR_FCO_ID") // []FCOStatusHistoryItem

s := ssi.NewStream(auth)
defer s.Disconnect()

if err := s.Connect(); err != nil {
    log.Fatal(err)
}

// Chờ cho tới khi ngắt kết nối
s.Wait(nil)

// Chờ với timeout (millisecond)
timeoutMs := 30000
s.Wait(&timeoutMs)

import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/stream"

s.Streaming.SetOnData(func(msg interface{}) {
    switch m := msg.(type) {
    case *stream.TradeMessage:
        fmt.Printf("[TRADE] %s | Giá: %.0f | KL: %d\n", m.Symbol, m.Price, m.Quantity)
    case *stream.QuoteMessage:
        fmt.Printf("[QUOTE] %s | Mua: %v | Bán: %v\n", m.Symbol, m.BidPrices, m.AskPrices)
    case *stream.ForeignRoomMessage:
        fmt.Printf("[ROOM] %s | KL Mua: %d | KL Bán: %d\n", m.Symbol, m.BuyQuantity, m.SellQuantity)
    case *stream.MarketStatusMessage:
        fmt.Printf("[MARKET] %s | Trạng thái: %s\n", m.Market, m.Status)
    case *stream.MarketDataMessage:
        if m.RefPrice != nil { // nil = server không gửi key này
            fmt.Printf("[MASTER] %s | Ref: %.0f\n", m.Symbol, *m.RefPrice)
        }
    case *stream.PutMessage:
        fmt.Printf("[PUT] %s | %.0f x %d\n", m.Symbol, m.Price, m.Quantity)
    case *stream.OddLotMessage:
        fmt.Printf("[ODDLOT] %s | %.0f x %d\n", m.Symbol, m.Price, m.Quantity)
    case *stream.IntervalMessage:
        fmt.Printf("[OHLCV] %s | O=%.0f H=%.0f L=%.0f C=%.0f V=%d\n",
            m.Symbol, m.Open, m.High, m.Low, m.Close, m.Volume)
    case *stream.IndexTickMessage:
        if m.Value != nil {
            fmt.Printf("[INDEX] %s | Value: %.2f\n", m.Symbol, *m.Value)
        }
    }
})

s.Streaming.SetOnTrading(func(msg interface{}) {
    switch m := msg.(type) {
    case *stream.OrderStatusMessage:
        fmt.Printf("[ORDER] %s %s | Trạng thái: %s\n", m.Symbol, m.Side, m.Status)
    case *stream.OrderMatchMessage:
        fmt.Printf("[MATCH] %s %s | %.0f x %d\n", m.Symbol, m.Side, m.MatchPrice, m.MatchQty)
    case *stream.FCOOrderUpdateMessage:
        fmt.Printf("[FCO ORDER] %s | ProcessStatus: %s\n", m.Symbol, m.ProcessStatus)
    case *stream.PortfolioMessage:
        // Chỉ tài khoản phái sinh. TotalAsset, CashBalance và StockValue luôn là nil.
        fmt.Printf("[PORTFOLIO] %s | %s | Net: %d\n", m.AccountNo, m.Symbol, m.Net)
    }
})

s.Streaming.SetOnHeartbeat(func(msg *stream.HeartbeatMessage) {
    fmt.Printf("[HEARTBEAT] %v\n", msg)
})

import "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/market"

// Tất cả kênh (trade + quote + room) cho mã
s.Streaming.SubscribeSymbol([]string{"SSI", "HPG", "VIC"}, nil)

// Kênh riêng lẻ
s.Streaming.SubscribeSymbolTrade([]string{"SSI", "HPG"}, nil)
s.Streaming.SubscribeSymbolQuote([]string{"SSI", "HPG"}, nil)
s.Streaming.SubscribeSymbolRoom([]string{"SSI", "HPG"}, nil)
s.Streaming.SubscribeSymbolPutThrough([]string{"SSI"}, nil)
s.Streaming.SubscribeSymbolOddLot([]string{"SSI"}, nil)

// OHLCV theo timeframe
s.Streaming.SubscribeSymbolOhlcv([]string{"SSI"}, market.TimeframeMinute1, nil)

// Master data (giá trần / sàn / tham chiếu)
s.Streaming.SubscribeMarket([]string{"SSI"}, nil)

// Theo sàn
s.Streaming.SubscribeBoard([]market.Board{market.BoardHOSE, market.BoardHNX}, nil)

// Các mã thành phần của một chỉ số (không phải bản thân chỉ số, xem 6.8)
s.Streaming.SubscribeIndex([]string{"VNINDEX", "VN30"}, nil)

s.Streaming.UnsubscribeSymbol([]string{"SSI", "HPG"})
s.Streaming.UnsubscribeSymbolTrade([]string{"SSI"})
s.Streaming.UnsubscribeSymbolQuote([]string{"SSI"})
s.Streaming.UnsubscribeSymbolRoom([]string{"SSI"})
s.Streaming.UnsubscribeSymbolPutThrough([]string{"SSI"})
s.Streaming.UnsubscribeSymbolOddLot([]string{"SSI"})
s.Streaming.UnsubscribeSymbolOhlcv([]string{"SSI"}, market.TimeframeMinute1)
s.Streaming.UnsubscribeMarket([]string{"SSI"})
s.Streaming.UnsubscribeBoard([]market.Board{market.BoardHOSE})
s.Streaming.UnsubscribeIndex([]string{"VNINDEX"})

// Trạng thái lệnh và khớp lệnh: tất cả tài khoản (account rỗng nghĩa là "*")
s.Streaming.SubscribeOrderStatus("", nil)

// Cho tài khoản cụ thể
s.Streaming.SubscribeOrderStatus("YOUR_ACCOUNT_NO", nil)

// Danh mục (cập nhật vị thế phái sinh): tất cả tài khoản
s.Streaming.SubscribePortfolio("", nil)

// Cho tài khoản cụ thể
s.Streaming.SubscribePortfolio("YOUR_ACCOUNT_NO", nil)

// Huỷ subscribe
s.Streaming.UnsubscribeOrderStatus("YOUR_ACCOUNT_NO")
s.Streaming.UnsubscribePortfolio("YOUR_ACCOUNT_NO")

// Ping một lần (không callback, không lặp)
s.Streaming.Ping(nil, nil)

// Ping lặp lại theo chu kỳ (millisecond; ping đầu tiên sau một chu kỳ)
intervalMs := 30000
s.Streaming.Ping(nil, &intervalMs)

// Dừng ping loop tự động
s.Streaming.StopPingLoop()

if s.Streaming.IsConnected() {
    fmt.Println("WebSocket connected")
}

fmt.Println(s.Streaming.ReconnectCount()) // số lần kết nối được thiết lập lại
if err := s.Streaming.LastError(); err != nil {
    fmt.Printf("lỗi kết nối gần nhất: %v\n", err)
}

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/ssi"
    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/stream"
    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/transport"
)

func main() {
    config := ssi.NewConfig(os.Getenv("SSI_CLIENT_ID"))
    config.APIKey = os.Getenv("SSI_API_KEY")
    config.APISecret = os.Getenv("SSI_API_SECRET")

    a := ssi.NewAuth(config)
    defer a.Close()
    if _, err := a.Authenticate(os.Getenv("SSI_OTP")); err != nil {
        log.Fatalf("Authenticate: %v", err)
    }

    s := ssi.NewStream(a)
    defer s.Disconnect()

    s.Streaming.SetOnConnection(func(e transport.ConnectionEvent) {
        fmt.Printf("connection: state=%s reconnects=%d\n", e.State, e.ReconnectCount)
        if e.Err != nil {
            fmt.Printf("connection error: %v\n", e.Err)
        }
    })

    s.Streaming.SetOnData(func(msg interface{}) {
        switch m := msg.(type) {
        case *stream.IndexTickMessage:
            if m.Value != nil { // nil = server không gửi key này
                fmt.Printf("%s value=%.2f\n", m.Symbol, *m.Value)
            }
        case *stream.IntervalMessage:
            fmt.Printf("%s candle %s O=%.2f H=%.2f L=%.2f C=%.2f V=%d\n",
                m.Symbol, m.IntervalTime, m.Open, m.High, m.Low, m.Close, m.Volume)
        }
    })

    if err := s.Connect(); err != nil {
        log.Fatalf("Connect: %v", err)
    }

    // Tick của chính chỉ số.
    if err := s.Streaming.SubscribeIndexTrade([]string{"VNINDEX"}, stream.IntervalTick, nil); err != nil {
        log.Fatalf("SubscribeIndexTrade: %v", err) // ValidationError nếu interval/topic sai
    }

    waitMs := 60000
    s.Wait(&waitMs) // chờ tối đa 60 giây (chỉ để minh hoạ)
}

// Nến 1 phút cần đúng một mã cụ thể, không dùng wildcard.
if err := s.Streaming.SubscribeIndexTrade([]string{"VN30"}, stream.IntervalMinute1, nil); err != nil {
    log.Printf("SubscribeIndexTrade 1m: %v", err)
}

s.Streaming.SetOnIndexSummary(func(m *stream.IndexSummaryMessage) {
    // Các trường chưa được công bố: dùng Get với key bạn biết, hoặc xem Data.
    fmt.Printf("summary %s: %d keys\n", m.Index, len(m.Data))
})
if err := s.Streaming.SubscribeIndexSummary([]string{"VNINDEX", "VN30"}, nil); err != nil {
    log.Printf("SubscribeIndexSummary: %v", err)
}

// Cờ phiên của mọi sàn.
s.Streaming.SetOnMarketFlag(func(m *stream.MarketFlagMessage) {
    fmt.Printf("flag: board=%s flag=%s\n", m.Board, m.Flag)
})
_ = s.Streaming.SubscribeMarketFlag(nil)

import (
    "errors"

    ssisdk "github.com/SSI-Securities-Inc/ssi-sdk-go/v3"
)

if err := s.Streaming.SubscribeIndexTrade([]string{"VNINDEX"}, "10s", nil); err != nil {
    var vErr *ssisdk.ValidationError
    if errors.As(err, &vErr) {
        log.Printf("dữ liệu sai, chưa gửi gì: %v", vErr)
    }
}

s.Streaming.SetOnConnection(func(e transport.ConnectionEvent) {
    switch e.State {
    case "failed":
        log.Printf("stream failed: %v (xác thực lại bằng OTP mới)", e.Err)
    default:
        log.Printf("stream state=%s reconnects=%d", e.State, e.ReconnectCount)
    }
})

// Xem kết nối này đang subscribe gì.
current, err := s.Streaming.ListSubscription(5000) // 5000 ms
if err != nil {
    log.Printf("ListSubscription: %v", err) // *WebSocketError khi timeout
} else {
    fmt.Printf("data topics: %d, trading topics: %d\n",
        len(current["data"]), len(current["trading"]))
}

// Huỷ một nhóm cụ thể: truyền đúng interval đã subscribe.
_ = s.Streaming.UnsubscribeIndexTrade([]string{"VN30"}, stream.IntervalMinute1)

// Hoặc huỷ mọi thứ server đang giữ cho kết nối này.
removed, err := s.Streaming.UnsubscribeAll()
if err != nil {
    log.Printf("UnsubscribeAll: %v", err)
} else {
    fmt.Printf("removed data topics: %d\n", len(removed["data"]))
}

ws, err := tradingws.TradingWS(ctx, a,
    tradingws.WithRequestTimeoutMs(15000),
    tradingws.WithRespectRateLimit(true),
    tradingws.WithMaxRateLimitWaitMs(5000),
)
if err != nil {
    return err
}
defer ws.Close() // bắt buộc: đóng socket và đánh thức mọi request đang chờ

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/ssi"
    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/trading"
    "github.com/SSI-Securities-Inc/ssi-sdk-go/v3/tradingws"
)

func main() {
    config := ssi.NewConfig(os.Getenv("SSI_CLIENT_ID"))
    config.APIKey = os.Getenv("SSI_API_KEY")
    config.APISecret = os.Getenv("SSI_API_SECRET")
    config.PrivateKey = os.Getenv("SSI_PRIVATE_KEY") // bắt buộc để ký lệnh

    a := ssi.NewAuth(config)
    defer a.Close()
    if _, err := a.Authenticate(os.Getenv("SSI_OTP")); err != nil {
        log.Fatalf("Authenticate: %v", err)
    }

    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    ws, err := tradingws.TradingWS(ctx, a,
        tradingws.WithRequestTimeoutMs(15000),
        tradingws.WithRespectRateLimit(true),
        tradingws.WithMaxRateLimitWaitMs(5000),
    )
    if err != nil {
        log.Fatalf("TradingWS: %v", err)
    }
    defer ws.Close()

    // Sự kiện và ack không có command id đến đây.
    // Chỉ in channel và eventType, đừng in cả frame.
    ws.Client().SetOnEvent(func(frame map[string]interface{}) {
        data, _ := frame["data"].(map[string]interface{})
        fmt.Printf("event: channel=%v eventType=%v\n", frame["channel"], data["eventType"])
    })

    accountNo := "YOUR_ACCOUNT_NO"
    if err := ws.SubscribeOrderEvents(accountNo); err != nil {
        log.Fatalf("SubscribeOrderEvents: %v", err)
    }

    placed, err := ws.PlaceOrder(ctx, accountNo, "SSI", trading.OrderSideBuy,
        100, 25000, trading.OrderTypeLO, "WS-0001")
    if err != nil {
        reportWSError("PlaceOrder", err) // xem 7.9
        return
    }
    // Đây mới chỉ là ack (thường là PD). Kết quả thật đến dưới dạng sự kiện lệnh.
    fmt.Printf("ack: OrderID=%s Status=%s\n", placed.OrderID, placed.Status)

    time.Sleep(5 * time.Second) // chờ vài sự kiện rồi thoát (chỉ để minh hoạ)
}

book, err := ws.QueryOrderBook(ctx, tradingws.OrderBookQuery{
    AccountNo: accountNo,
    FromDate:  "2026/01/01",
    ToDate:    "2026/01/01",
    Symbol:    "SSI",
    PageIndex: 1,
    PageSize:  20,
})
if err != nil {
    reportWSError("QueryOrderBook", err)
    return
}
fmt.Printf("status=%d method=%s\n", book.Status, book.Method)
if result, ok := book.Result.(map[string]interface{}); ok {
    fmt.Printf("keys in result: %d\n", len(result))
}

// Quota mới nhất server báo (remaining, resetMs, ...).
fmt.Printf("rateLimit: %v\n", ws.Client().RateLimit())

if !ws.Client().IsConnected() {
    if err := ws.Client().Connect(ctx); err != nil {
        reportWSError("Connect", err)
        return
    }
    // Subscription không được khôi phục tự động.
    if err := ws.SubscribeOrderEvents(accountNo); err != nil {
        log.Printf("resubscribe: %v", err)
    }
    // Command gửi trước khi rớt có thể đã được nhận: đối chiếu bằng
    // QueryOrderBook hoặc sự kiện lệnh trước khi gửi lại.
}

import (
    "context"
    "errors"
    "fmt"

    ssisdk "github.com/SSI-Securities-Inc/ssi-sdk-go/v3"
)

func reportWSError(op string, err error) {
    var wsErr *ssisdk.TradingWSError
    var vErr *ssisdk.ValidationError
    var connErr *ssisdk.WebSocketError

    switch {
    case errors.As(err, &wsErr):
        // Server từ chối: Status, ErrorCode, ServerMessage.
        // Status 429 là rate limit; 401/403 là token hoặc scope.
        fmt.Printf("%s: server từ chối status=%d code=%s: %s\n",
            op, wsErr.Status, wsErr.ErrorCode, wsErr.ServerMessage)
    case errors.As(err, &vErr):
        fmt.Printf("%s: dữ liệu không hợp lệ (chưa gửi gì): %v\n", op, vErr)
    case errors.Is(err, context.DeadlineExceeded), errors.Is(err, context.Canceled):
        fmt.Printf("%s: context đã kết thúc: %v\n", op, err)
    case errors.As(err, &connErr):
        // Timeout (không retry), mất kết nối, hoặc chưa kết nối.
        fmt.Printf("%s: lỗi websocket: %v\n", op, connErr)
    default:
        fmt.Printf("%s: lỗi: %v\n", op, err)
    }
}