API Services

var token = await auth.AuthenticateAsync("222222");
Console.WriteLine($"Access token: {token.AccessToken}");
Console.WriteLine($"Expires at: {token.ExpiresAt}");

var result = await auth.RequestOtpAsync();

var token = await auth.RefreshAsync();

var accessToken = await auth.EnsureAuthenticatedAsync("222222");

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);

var raw = await data.MarketData.DownloadOhlc1MinuteAsync("SSI");
var rawDay = await data.MarketData.DownloadOhlc1DayAsync("SSI");

// 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");

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

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

// Vị thế cơ sở
var positions = await trading.Portfolio.GetEquityPositionsAsync("1234561");
foreach (var pos in positions)
{
    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("1234568");

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

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

// Lệnh trong ngày
var todayOrders = await trading.Portfolio.GetTodayOrdersAsync("1234561");
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(
    "1234561", fromDate: "2026/01/01", toDate: "2026/01/31");

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

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

// Lệnh giới hạn (LO)
var result = await trading.Trading.PlaceLimitOrderAsync(
    accountNo: "1234561", 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(
    "1234561", "SSI", OrderSide.Buy, 100);

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

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

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

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

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

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

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

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

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

// Với giá cụ thể
var maxBS = await trading.Trading.GetMaxBuySellAsync("1234561", "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("1234561", "SSI");

using SsiSdk;

string accountNo = "1234561";
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.5, fromDate, toDate);

// Lệnh Stop (dừng thị trường)
var stop = await trading.Trading.PlaceFcoStopAsync(
    accountNo, "SSI", OrderSide.Sell, 100, 24000, 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.5, 25000, 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, 26000, 1000, fromDate, toDate);

// Lệnh Trailing Stop Limit
var trailingLimit = await trading.Trading.PlaceFcoTrailingStopLimitAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 26000, 1000, 0.5, 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, 30000, 24000, OrderType.MTL, OrderType.MTL, 0.5, 0.5, fromDate, toDate);

// Lệnh Bull Bear
var bullBear = await trading.Trading.PlaceFcoBullBearAsync(
    accountNo, "SSI", OrderSide.Buy, 1000, 100.5, 0.5, 30, 20, 30, 10, 0.1, 0, 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("1234561");

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

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

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

// Lấy một lệnh FCO cụ thể bằng ID
var fcoInfo = await trading.Trading.GetFcoByIdAsync("1234561", "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");

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
await stream.WaitAsync(TimeSpan.FromSeconds(30));

stream.Disconnect();                // Ngắt kết nối thủ công (nếu không dùng using)

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
await stream.Streaming.SubscribeBoardAsync([Board.HOSE, Board.HNX]);

// Theo chỉ số
await stream.Streaming.SubscribeIndexAsync(["VNINDEX", "VN30"]);

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"]);

// 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("1234561");

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

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

// Ping tự động theo interval (giây)
await stream.Streaming.PingAsync(intervalSeconds: 30);

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