API Services

var token = await auth.AuthenticateAsync("YOUR_OTP");
Console.WriteLine($"Expires at (epoch seconds): {token.ExpiresAt}");

OtpResponse otp = await auth.RequestOtpTypedAsync();
Console.WriteLine(otp.Message);
// otp.TransactionId (string?) dùng cho luồng Smart OTP

var token = await auth.RefreshAsync();

// OTP thường
var accessToken = await auth.EnsureAuthenticatedAsync("YOUR_OTP");

// Smart OTP (duyệt trên app): polling theo Config.OtpPollIntervalMs / OtpPollMaxWaitMs
var otp = await auth.RequestOtpTypedAsync();
await auth.EnsureAuthenticatedAsync(transactionId: otp.TransactionId);

var accounts = await trading.Account.GetAccountInfoAsync();

foreach (var acc in accounts)
{
    Console.WriteLine($"{acc.AccountNo} - {acc.AccountType}");
}

var ohlc = await data.MarketData.GetOhlc1MinuteAsync("SSI");
foreach (var candle in ohlc)
{
    Console.WriteLine($"{candle.TradingDate}: O={candle.OpenPrice} H={candle.HighPrice} L={candle.LowPrice} C={candle.ClosePrice} V={candle.Volume}");
}

var ohlc = await data.MarketData.GetOhlc1DayHistoricalAsync(
    symbol: "SSI",
    fromDate: "2026/03/27",
    toDate: "2026/04/22",
    page: 1,
    size: 100);

// IAsyncEnumerable<OhlcData>, tự phân trang (size mặc định 1000)
await foreach (var c in data.MarketData.IterOhlcAsync("SSI", Timeframe.Minute5, "2026/03/01", "2026/03/31"))
{
    Console.WriteLine($"{c.TradingDate} C={c.ClosePrice}");
}

// Gom thành List (ascending = false là mặc định)
List<OhlcData> all = await data.MarketData.GetOhlcAllAsync("SSI", Timeframe.Day1, "2026/03/01", "2026/03/31");

// Tất cả chỉ số
var indexes = await data.MarketData.GetIndexesAsync();

// Theo sàn
var indexesByBoard = await data.MarketData.GetIndexesByBoardAsync(Board.HOSE);

foreach (var idx in indexes)
{
    Console.WriteLine($"{idx.Index} - {idx.IndexName}");
}

// Summary hiện tại
var summary = await data.MarketData.GetIndexSummaryAsync("VNINDEX");

// Summary lịch sử
var summaryHist = await data.MarketData.GetIndexSummaryHistoricalAsync("VNINDEX", "2026/01/15");

// Summary theo sàn
var boardSummary = await data.MarketData.GetBoardSummaryAsync(Board.HOSE);

// Summary sàn lịch sử
var boardSummaryHist = await data.MarketData.GetBoardSummaryHistoricalAsync(Board.HOSE, "2026/01/15");

// 1 mã
var info = await data.MarketData.GetSecuritiesInfoAsync("SSI");

// Theo chỉ số
var byIndex = await data.MarketData.GetSecuritiesInfoByIndexAsync("VN30");

// Theo sàn
var byBoard = await data.MarketData.GetSecuritiesInfoByBoardAsync(Board.HOSE);

// Summary hiện tại
var summary = await data.MarketData.GetSecuritiesSummaryAsync("SSI");

// Summary lịch sử
var summaryHist = await data.MarketData.GetSecuritiesSummaryHistoricalAsync(
    symbol: "SSI", fromDate: "2026/03/01", toDate: "2026/03/31");

// Summary theo chỉ số
var byIndex = await data.MarketData.GetSecuritiesSummaryByIndexAsync("VN30");

// Summary theo chỉ số lịch sử
var byIndexHist = await data.MarketData.GetSecuritiesSummaryByIndexHistoricalAsync(
    index: "VN30", fromDate: "2026/03/01", toDate: "2026/03/31");

// Hôm nay
List<MasterData> today = await data.MarketData.GetMasterDataAsync();

// Lịch sử
List<MasterData> hist = await data.MarketData.GetMasterDataHistoricalAsync("2026/03/01", "2026/03/31");

// Hôm nay (mọi mã, hoặc một mã)
List<CorporateAction> today = await data.MarketData.GetCorporateActionsAsync();
List<CorporateAction> ssi = await data.MarketData.GetCorporateActionsAsync("SSI", "en");

// Quá khứ: khoảng ngày tối đa 5 ngày
List<CorporateAction> past = await data.MarketData.GetCorporateActionsHistoricalAsync(
    fromDate: "2026/10/08", toDate: "2026/10/12",
    symbol: null,       // null = tất cả mã
    language: "vn");    // "vn" (mặc định) hoặc "en"

foreach (var e in past)
{
    Console.WriteLine($"{e.Symbol} {e.EventTitle} {e.ExrightDate} {e.RecordDate} {e.IssueDate} {e.Exchange} {e.Ratio}");
}

// Số dư cơ sở
var equityBalance = await trading.Portfolio.GetEquityBalanceAsync("YOUR_ACCOUNT_NO");
Console.WriteLine($"Available cash: {equityBalance?.AccountBalance}");

// Số dư phái sinh
var derivativeBalance = await trading.Portfolio.GetDerivativeBalanceAsync("YOUR_ACCOUNT_NO");
Console.WriteLine($"Withdrawable: {derivativeBalance?.Withdrawable}");

// Vị thế cơ sở
var positions = await trading.Portfolio.GetEquityPositionsAsync("YOUR_ACCOUNT_NO");
foreach (var pos in positions ?? new List<EquityPosition>()) // có thể trả về null
{
    Console.WriteLine($"{pos.Symbol}: {pos.Quantity} cp | Giá vốn: {pos.CostPrice}");
}

// Tất cả vị thế phái sinh (chia Open/Closed)
var allDerivative = await trading.Portfolio.GetDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Chỉ vị thế mở phái sinh
var openPos = await trading.Portfolio.GetOpenDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Chỉ vị thế đóng phái sinh
var closedPos = await trading.Portfolio.GetClosedDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Lệnh trong ngày
var todayOrders = await trading.Portfolio.GetTodayOrdersAsync("YOUR_ACCOUNT_NO");
foreach (var order in todayOrders)
{
    Console.WriteLine($"{order.OrderId}: {order.Symbol} {order.Side} {order.Quantity}@{order.Price} - {order.Status}");
}

// Lệnh lịch sử
var historicalOrders = await trading.Portfolio.GetHistoricalOrdersAsync(
    "YOUR_ACCOUNT_NO", fromDate: "2026/01/01", toDate: "2026/01/31");

// PPMMR cơ sở
var equityPpmmr = await trading.Portfolio.GetEquityPpmmrAsync("YOUR_ACCOUNT_NO");
Console.WriteLine($"Purchasing power: {equityPpmmr?.PurchasingPower}");

// PPMMR phái sinh
var derivativePpmmr = await trading.Portfolio.GetDerivativePpmmrAsync("YOUR_ACCOUNT_NO");

// Lệnh giới hạn (LO)
var result = await trading.Trading.PlaceLimitOrderAsync(
    accountNo: "YOUR_ACCOUNT_NO", symbol: "SSI", side: OrderSide.Buy, quantity: 100, price: 66000);
Console.WriteLine($"Order ID: {result.OrderId}, Status: {result.Status}");

// Lệnh thị trường (MTL)
var market = await trading.Trading.PlaceMarketOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100);

// Lệnh ATO (mở cửa)
var ato = await trading.Trading.PlaceAtoOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100);

// Lệnh ATC (đóng cửa)
var atc = await trading.Trading.PlaceAtcOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Sell, 100);

// Lệnh tuỳ chỉnh (chỉ định OrderType)
var custom = await trading.Trading.PlaceOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100, 66000, OrderType.LO);

// Sửa giá theo ClientRequestId
var r1 = await trading.Trading.ModifyOrderPriceAsync("YOUR_ACCOUNT_NO", "REQ123", 68000);

// Sửa giá theo OrderId
var r2 = await trading.Trading.ModifyOrderPriceByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123", 68000);

// Sửa khối lượng theo ClientRequestId
var r3 = await trading.Trading.ModifyOrderQuantityAsync("YOUR_ACCOUNT_NO", "REQ123", 200);

// Sửa khối lượng theo OrderId
var r4 = await trading.Trading.ModifyOrderQuantityByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123", 200);

// Huỷ theo ClientRequestId
var c1 = await trading.Trading.CancelOrderAsync("YOUR_ACCOUNT_NO", "REQ123");

// Huỷ theo OrderId
var c2 = await trading.Trading.CancelOrderByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123");

// Với giá cụ thể
var maxBS = await trading.Trading.GetMaxBuySellAsync("YOUR_ACCOUNT_NO", "SSI", 66000);
Console.WriteLine($"Max buy: {maxBS.MaxBuyQuantity}");
Console.WriteLine($"Max sell: {maxBS.MaxSellQuantity}");

// Với giá thị trường
var maxBSMarket = await trading.Trading.GetMaxBuySellAtMarketPriceAsync("YOUR_ACCOUNT_NO", "SSI");

using SsiSdk;

string accountNo = "YOUR_ACCOUNT_NO";
string fromDate = "2026/07/21 00:00:00";
string toDate = "2026/07/28 23:00:00";

// Lệnh GTD (Good Till Date)
var gtd = await trading.Trading.PlaceFcoGtdAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 25000, 0.5m, fromDate, toDate);

// Lệnh Stop (dừng thị trường)
var stop = await trading.Trading.PlaceFcoStopAsync(
    accountNo, "SSI", OrderSide.Sell, 100, 24000m, FCOOperator.LesserOrEqual, fromDate, toDate);

// Lệnh Stop Limit (dừng giới hạn)
var stopLimit = await trading.Trading.PlaceFcoStopLimitAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 25500, 0.5m, 25000m, FCOOperator.GreaterOrEqual, fromDate, toDate);

// Lệnh Trailing Stop (bám sát xu hướng)
var trailing = await trading.Trading.PlaceFcoTrailingStopAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 26000m, 1000m, fromDate, toDate);

// Lệnh Trailing Stop Limit
var trailingLimit = await trading.Trading.PlaceFcoTrailingStopLimitAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 26000m, 1000m, 0.5m, fromDate, toDate);

// Lệnh OCO (huỷ lệnh kia khi 1 trong 2 khớp)
var oco = await trading.Trading.PlaceFcoOcoAsync(
    accountNo, "SSI", OrderSide.Sell, 100, 30000m, 24000m, OrderType.MTL, OrderType.MTL, 0.5m, 0.5m, fromDate, toDate);

// Lệnh Bull Bear
var bullBear = await trading.Trading.PlaceFcoBullBearAsync(
    accountNo, "SSI", OrderSide.Buy, 1000, 100.5m, 0.5m, 30m, 20m, 30, 10, 0.1m, 0m, fromDate, toDate);

// Huỷ lệnh điều kiện
var cancelRes = await trading.Trading.CancelFcoAsync(gtd.FCOID);

// Lấy toàn bộ lệnh FCO theo tài khoản
var fcos = await trading.Trading.GetFcoByAccountNoAsync("YOUR_ACCOUNT_NO");

// Lấy FCO theo mã chứng khoán
var fcosBySymbol = await trading.Trading.GetFcoBySymbolAsync("YOUR_ACCOUNT_NO", "SSI");

// Lấy FCO theo trạng thái xử lý
var fcosByStatus = await trading.Trading.GetFcoByStatusAsync("YOUR_ACCOUNT_NO", FCOStatus.Trit);

// Lấy FCO theo khoảng thời gian
var fcosByDate = await trading.Trading.GetFcoByDateAsync("YOUR_ACCOUNT_NO", "2026/07/01", "2026/07/21");

// Lấy một lệnh FCO cụ thể bằng ID
var fcoInfo = await trading.Trading.GetFcoByIdAsync("YOUR_ACCOUNT_NO", "fco-id-here");

// Lấy nhật ký khớp lệnh (order book) của lệnh FCO
var orderBook = await trading.Trading.GetFcoOrderBookAsync("fco-id-here");

// Lịch sử trạng thái của lệnh FCO
List<FCOStatusHistoryItem> history = await trading.Trading.GetFcoStatusHistoryAsync("fco-id-here");

using SsiSdk;
using SsiSdk.Models;

var runId = Guid.NewGuid().ToString("N")[..8];
var items = new List<BatchPlaceOrderItem>
{
    new("YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100, 25000m, OrderType.LO, ClientRequestId: $"b-{runId}-1"),
    new("YOUR_ACCOUNT_NO", "VNM", OrderSide.Buy, 100, 60000m, OrderType.LO, ClientRequestId: $"b-{runId}-2"),
};

try
{
    var response = await trading.Trading.PlaceBatchOrdersAsync(items);
    foreach (var r in response.Results)
    {
        Console.WriteLine(r.Success
            ? $"OK   {r.ClientRequestId} -> OrderId={r.OrderId} Status={r.Status}"
            : $"FAIL {r.ClientRequestId}: {r.ErrorCode} {r.ErrorMessage}");
    }
}
catch (ValidationException ex)
{
    // Batch rỗng, vượt giới hạn, hoặc có lệnh không hợp lệ: chưa gửi gì
    Console.WriteLine($"SDK từ chối: {ex.Message}");
}
catch (DuplicateRequestException ex)
{
    Console.WriteLine($"Trùng lặp (409): {ex.Message}");
}
catch (RateLimitException ex)
{
    // SDK không gửi lại POST; tự chờ và quyết định
    Console.WriteLine($"Bị rate limit, thử lại sau {ex.RetryAfterMs} ms");
}
catch (AuthenticationException ex)
{
    Console.WriteLine($"Lỗi xác thực/chữ ký: {ex.Message}");
}
catch (ApiException ex)
{
    Console.WriteLine($"Lỗi API [{ex.Code}] HTTP {ex.StatusCode}: {ex.Message}");
}

static async Task CancelPlacedAsync(TradingClient trading, BatchOrderResponse placed)
{
    // Ưu tiên OrderId; nếu không có thì dùng ClientRequestId. Mỗi item đúng một mã.
    var cancelItems = placed.Results
        .Where(r => r.Success)
        .Select(r => !string.IsNullOrEmpty(r.OrderId)
            ? new BatchCancelOrderItem("YOUR_ACCOUNT_NO", OrderId: r.OrderId)
            : new BatchCancelOrderItem("YOUR_ACCOUNT_NO", ClientRequestId: r.ClientRequestId))
        .ToList();

    if (cancelItems.Count == 0) return;

    var cancelResponse = await trading.Trading.CancelBatchOrdersAsync(cancelItems);
    foreach (var r in cancelResponse.Results)
        Console.WriteLine($"{(r.Success ? "OK  " : "FAIL")} {r.ClientRequestId} {r.ErrorCode} {r.ErrorMessage}");
}

// allItems: List<BatchPlaceOrderItem> dựng như ví dụ 1
var limit = config.MaxBatchOrders;
foreach (var chunk in allItems.Chunk(limit))
{
    // Gửi lần lượt; để exception dừng vòng lặp thay vì gửi tiếp phần còn lại một cách mù quáng.
    var resp = await trading.Trading.PlaceBatchOrdersAsync(chunk);
    var failed = resp.Results.Count(r => !r.Success);
    Console.WriteLine($"batch xong: {resp.Results.Count} lệnh, {failed} lỗi");
}

using var stream = new StreamClient(auth);

await stream.ConnectAsync();       // Kết nối WebSocket

// Chờ vô thời hạn
await stream.WaitAsync();

// Chờ với timeout (mili-giây)
await stream.WaitAsync(timeoutMs: 30000);

await stream.DisconnectAsync();     // Ngắt kết nối thủ công (nếu không dùng using); cũng có bản đồng bộ Disconnect()

using SsiSdk.Models;

stream.Streaming.SetOnData(msg =>
{
    switch (msg)
    {
        case TradeMessage t: Console.WriteLine($"Trade: {t.Symbol} {t.Price}"); break;
        case QuoteMessage q: Console.WriteLine($"Quote: {q.Symbol}"); break;
    }
});

stream.Streaming.SetOnTrading(msg =>
{
    if (msg is OrderStatusMessage order)
        Console.WriteLine($"Order: {order.Symbol} {order.Status}");
});

stream.Streaming.SetOnHeartbeat(hb => Console.WriteLine($"Heartbeat: {hb.Status}"));

// Từng kênh riêng
await stream.Streaming.SubscribeSymbolTradeAsync(["SSI", "HPG"]);
await stream.Streaming.SubscribeSymbolQuoteAsync(["SSI", "HPG"]);
await stream.Streaming.SubscribeSymbolRoomAsync(["SSI", "HPG"]);
await stream.Streaming.SubscribeSymbolPutThroughAsync(["SSI"]);
await stream.Streaming.SubscribeSymbolOddLotAsync(["SSI"]);

// Tất cả kênh (trade + quote + room) cho mã
await stream.Streaming.SubscribeSymbolAsync(["SSI", "HPG", "VIC"]);

// OHLCV theo interval
await stream.Streaming.SubscribeSymbolOhlcvAsync(["SSI"], Timeframe.Minute1);

// Theo sàn (fan-out @*, xem lưu ý bên dưới)
await stream.Streaming.SubscribeBoardAsync([Board.HOSE, Board.HNX]);

// Theo chỉ số (fan-out @* các mã trong rổ, xem lưu ý bên dưới)
await stream.Streaming.SubscribeIndexAsync(["VNINDEX", "VN30"]);

// Master data (trần, sàn, tham chiếu) của mã hoặc sàn
await stream.Streaming.SubscribeMarketAsync(["SSI"]);

// Cờ phiên giao dịch (ATO, LO, ATC, ...) của các sàn
await stream.Streaming.SubscribeMarketFlagAsync();

// Tick, nến và tổng hợp của chính chỉ số: xem 6.7

await stream.Streaming.UnsubscribeSymbolTradeAsync(["SSI"]);
await stream.Streaming.UnsubscribeSymbolQuoteAsync(["SSI"]);
await stream.Streaming.UnsubscribeSymbolRoomAsync(["SSI"]);
await stream.Streaming.UnsubscribeSymbolPutThroughAsync(["SSI"]);
await stream.Streaming.UnsubscribeSymbolOddLotAsync(["SSI"]);
await stream.Streaming.UnsubscribeSymbolAsync(["SSI", "HPG"]);

// Huỷ OHLCV
await stream.Streaming.UnsubscribeSymbolOhlcvAsync(["SSI"], Timeframe.Minute1);

await stream.Streaming.UnsubscribeBoardAsync([Board.HOSE]);
await stream.Streaming.UnsubscribeIndexAsync(["VNINDEX"]);
await stream.Streaming.UnsubscribeMarketAsync(["SSI"]);
await stream.Streaming.UnsubscribeMarketFlagAsync();

// Huỷ tất cả và xem server đang giữ gì
var removed = await stream.Streaming.UnsubscribeAllAsync();               // Dictionary<string, List<string>>
var active = await stream.Streaming.ListSubscriptionAsync(timeoutMs: 5000); // khoá "trading" và "data"

// Trạng thái lệnh (tất cả tài khoản, mặc định "*")
await stream.Streaming.SubscribeOrderStatusAsync();

// Cho tài khoản cụ thể
await stream.Streaming.SubscribeOrderStatusAsync("YOUR_ACCOUNT_NO");

// Portfolio
await stream.Streaming.SubscribePortfolioAsync();
await stream.Streaming.SubscribePortfolioAsync("YOUR_ACCOUNT_NO");

// Ping một lần
await stream.Streaming.PingAsync();

// Ping tự động theo interval (mili-giây)
await stream.Streaming.PingAsync(intervalMs: 30000);

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

using SsiSdk;
using SsiSdk.Models;

stream.Streaming.OnConnection = e =>
    Console.WriteLine($"[CONN] {e.State} (reconnect #{e.ReconnectCount})" +
                      (e.Error is null ? "" : $" lỗi: {e.Error.GetType().Name}"));

stream.Streaming.OnData = msg =>
{
    switch (msg)
    {
        case IntervalMessage bar:
            Console.WriteLine($"[NẾN] {bar.Symbol} {bar.IntervalTime} O:{bar.Open} H:{bar.High} L:{bar.Low} C:{bar.Close} V:{bar.Volume}");
            break;
        case IndexTickMessage idx:
            Console.WriteLine($"[INDEX] {idx.Symbol} {idx.Value} ({idx.ChangePercent}%) tăng/giảm: {idx.Advances}/{idx.Declines}");
            break;
    }
};

await stream.ConnectAsync();

await stream.Streaming.SubscribeIndexTradeAsync(["VNINDEX", "VN30"]);       // tick
await stream.Streaming.SubscribeIndexTradeAsync(["VNINDEX"], "1m");         // nến 1 phút

await stream.WaitAsync(60_000);   // lắng nghe 60 giây

await stream.Streaming.UnsubscribeIndexTradeAsync(["VNINDEX", "VN30"]);
await stream.Streaming.UnsubscribeIndexTradeAsync(["VNINDEX"], "1m");      // cùng interval với lúc subscribe
await stream.DisconnectAsync();

stream.Streaming.OnIndexSummary = m =>
    Console.WriteLine($"[SUMMARY] {m.Index} value={m.Get("v")} change%={m.Get("cr")}");

await stream.ConnectAsync();
await stream.Streaming.SubscribeIndexSummaryAsync(["VNINDEX", "HNXINDEX"]);

await stream.WaitAsync(60_000);

var subs = await stream.Streaming.ListSubscriptionAsync(timeoutMs: 5000);
foreach (var (channel, topics) in subs)
    Console.WriteLine($"{channel}: {topics.Count} topic");

var removed = await stream.Streaming.UnsubscribeAllAsync();
Console.WriteLine($"Đã huỷ {removed.Values.Sum(v => v.Count)} topic");

using SsiSdk;
using SsiSdk.Models;

await using var ws = await TradingWs.ConnectAsync(auth);
Console.WriteLine($"Đã kết nối: {ws.Client.IsConnected}");

var account = "YOUR_ACCOUNT_NO";

static string Shape(TradingWsResponse r)
{
    var keys = r.Result.ValueKind == System.Text.Json.JsonValueKind.Object
        ? string.Join(",", r.Result.EnumerateObject().Select(p => p.Name).Take(8))
        : r.Result.ValueKind.ToString();
    return $"status={r.Status} method={r.Method} result=[{keys}]";
}

try
{
    await using var ws = await TradingWs.ConnectAsync(auth, new TradingWsOptions
    {
        RequestTimeoutMs = 10_000,
        PingIntervalMs = 30_000,
    });

    var events = 0;
    ws.Client.OnEvent = _ => Interlocked.Increment(ref events);

    Console.WriteLine(Shape(await ws.QueryAccountBalanceAsync(account)));
    Console.WriteLine(Shape(await ws.QueryPositionAsync(account)));
    Console.WriteLine(Shape(await ws.QueryMaxBuySellAsync(account, "SSI")));

    await ws.SubscribeOrderEventsAsync(account);
    await Task.Delay(TimeSpan.FromSeconds(30));
    await ws.UnsubscribeOrderEventsAsync(account);
    Console.WriteLine($"Số sự kiện nhận được: {events}");
}
catch (TradingWsError ex)
{
    // Server từ chối socket hoặc một lệnh
    Console.WriteLine($"Trading WS bị từ chối: status={ex.Status} code={ex.ErrorCode} {ex.ServerMessage}");
}
catch (SsiException ex)
{
    Console.WriteLine($"Lỗi: {ex.GetType().Name} [{ex.Code}] {ex.Message}");
}

var account = "YOUR_ACCOUNT_NO";
var clientRequestId = $"ws-{Guid.NewGuid().ToString("N")[..8]}";   // tối đa 20 ký tự

try
{
    await using var ws = await TradingWs.ConnectAsync(auth);

    // Theo dõi kết quả thật trên luồng sự kiện lệnh
    ws.Client.OnEvent = _ => Console.WriteLine("đã nhận sự kiện lệnh");
    await ws.SubscribeOrderEventsAsync(account);

    var placed = await ws.PlaceOrderAsync(
        account, "SSI", OrderSide.Buy, 100, 20000m, OrderType.LO, clientRequestId);
    Console.WriteLine("order.place đã được xác nhận");

    // Frame xác nhận có thể không có orderId: huỷ theo clientRequestId
    var cancelled = await ws.CancelOrderAsync(account, clientRequestId: clientRequestId);
    Console.WriteLine("order.cancel đã được xác nhận");
}
catch (TradingWsError ex)
{
    Console.WriteLine($"Bị từ chối: status={ex.Status} code={ex.ErrorCode} {ex.ServerMessage}");
}
catch (ValidationException ex)
{
    Console.WriteLine($"Đầu vào không hợp lệ (chưa gửi gì): {ex.Message}");
}
catch (WebSocketException ex)
{
    // Timeout, socket đóng hoặc thiếu PrivateKey. Sau timeout, lệnh có thể đã hoặc chưa được tạo.
    Console.WriteLine($"Lỗi WebSocket: {ex.Message}");
}

var runId = Guid.NewGuid().ToString("N")[..8];
var items = new List<BatchPlaceOrderItem>
{
    new("YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100, 20000m, OrderType.LO, ClientRequestId: $"w-{runId}-1"),
    new("YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100, 19950m, OrderType.LO, ClientRequestId: $"w-{runId}-2"),
};

var response = await ws.BatchNewOrdersAsync(items);   // ws: TradingWsService lấy từ ConnectAsync

// Kết quả là JSON thô: chỉ in hình dạng, rồi đọc trạng thái cuối từ sự kiện lệnh
var kind = response.Result.ValueKind;
Console.WriteLine($"status={response.Status} method={response.Method} result={kind}");