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?) is used by the Smart OTP flow

var token = await auth.RefreshAsync();

// Regular OTP
var accessToken = await auth.EnsureAuthenticatedAsync("YOUR_OTP");

// Smart OTP (approve in the app): polls using 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>, pages automatically (default size 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}");
}

// Collect into a List (ascending = false by default)
List<OhlcData> all = await data.MarketData.GetOhlcAllAsync("SSI", Timeframe.Day1, "2026/03/01", "2026/03/31");

// All indexes
var indexes = await data.MarketData.GetIndexesAsync();

// By board
var indexesByBoard = await data.MarketData.GetIndexesByBoardAsync(Board.HOSE);

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

// Current summary
var summary = await data.MarketData.GetIndexSummaryAsync("VNINDEX");

// Historical summary
var summaryHist = await data.MarketData.GetIndexSummaryHistoricalAsync("VNINDEX", "2026/01/15");

// Board summary
var boardSummary = await data.MarketData.GetBoardSummaryAsync(Board.HOSE);

// Historical board summary
var boardSummaryHist = await data.MarketData.GetBoardSummaryHistoricalAsync(Board.HOSE, "2026/01/15");

// Single symbol
var info = await data.MarketData.GetSecuritiesInfoAsync("SSI");

// By index
var byIndex = await data.MarketData.GetSecuritiesInfoByIndexAsync("VN30");

// By board
var byBoard = await data.MarketData.GetSecuritiesInfoByBoardAsync(Board.HOSE);

// Current summary
var summary = await data.MarketData.GetSecuritiesSummaryAsync("SSI");

// Historical summary
var summaryHist = await data.MarketData.GetSecuritiesSummaryHistoricalAsync(
    symbol: "SSI", fromDate: "2026/03/01", toDate: "2026/03/31");

// By index
var byIndex = await data.MarketData.GetSecuritiesSummaryByIndexAsync("VN30");

// By index, historical
var byIndexHist = await data.MarketData.GetSecuritiesSummaryByIndexHistoricalAsync(
    index: "VN30", fromDate: "2026/03/01", toDate: "2026/03/31");

// Today
List<MasterData> today = await data.MarketData.GetMasterDataAsync();

// Historical
List<MasterData> hist = await data.MarketData.GetMasterDataHistoricalAsync("2026/03/01", "2026/03/31");

// Today (all symbols, or one symbol)
List<CorporateAction> today = await data.MarketData.GetCorporateActionsAsync();
List<CorporateAction> ssi = await data.MarketData.GetCorporateActionsAsync("SSI", "en");

// Past: a date range of at most 5 days
List<CorporateAction> past = await data.MarketData.GetCorporateActionsHistoricalAsync(
    fromDate: "2026/10/08", toDate: "2026/10/12",
    symbol: null,       // null = all symbols
    language: "vn");    // "vn" (default) or "en"

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

// Equity balance
var equityBalance = await trading.Portfolio.GetEquityBalanceAsync("YOUR_ACCOUNT_NO");
Console.WriteLine($"Available cash: {equityBalance?.AccountBalance}");

// Derivative balance
var derivativeBalance = await trading.Portfolio.GetDerivativeBalanceAsync("YOUR_ACCOUNT_NO");
Console.WriteLine($"Withdrawable: {derivativeBalance?.Withdrawable}");

// Equity positions
var positions = await trading.Portfolio.GetEquityPositionsAsync("YOUR_ACCOUNT_NO");
foreach (var pos in positions ?? new List<EquityPosition>()) // may return null
{
    Console.WriteLine($"{pos.Symbol}: {pos.Quantity} shares | Cost: {pos.CostPrice}");
}

// All derivative positions (split into Open/Closed)
var allDerivative = await trading.Portfolio.GetDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Open derivative positions only
var openPos = await trading.Portfolio.GetOpenDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Closed derivative positions only
var closedPos = await trading.Portfolio.GetClosedDerivativePositionsAsync("YOUR_ACCOUNT_NO");

// Today's orders
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}");
}

// Historical orders
var historicalOrders = await trading.Portfolio.GetHistoricalOrdersAsync(
    "YOUR_ACCOUNT_NO", fromDate: "2026/01/01", toDate: "2026/01/31");

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

// Derivative PPMMR
var derivativePpmmr = await trading.Portfolio.GetDerivativePpmmrAsync("YOUR_ACCOUNT_NO");

// Limit order (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}");

// Market order (MTL)
var market = await trading.Trading.PlaceMarketOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100);

// ATO order (opening)
var ato = await trading.Trading.PlaceAtoOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100);

// ATC order (closing)
var atc = await trading.Trading.PlaceAtcOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Sell, 100);

// Custom order type
var custom = await trading.Trading.PlaceOrderAsync(
    "YOUR_ACCOUNT_NO", "SSI", OrderSide.Buy, 100, 66000, OrderType.LO);

// Modify price by ClientRequestId
var r1 = await trading.Trading.ModifyOrderPriceAsync("YOUR_ACCOUNT_NO", "REQ123", 68000);

// Modify price by OrderId
var r2 = await trading.Trading.ModifyOrderPriceByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123", 68000);

// Modify quantity by ClientRequestId
var r3 = await trading.Trading.ModifyOrderQuantityAsync("YOUR_ACCOUNT_NO", "REQ123", 200);

// Modify quantity by OrderId
var r4 = await trading.Trading.ModifyOrderQuantityByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123", 200);

// Cancel by ClientRequestId
var c1 = await trading.Trading.CancelOrderAsync("YOUR_ACCOUNT_NO", "REQ123");

// Cancel by OrderId
var c2 = await trading.Trading.CancelOrderByOrderIdAsync("YOUR_ACCOUNT_NO", "ORD123");

// With a specific price
var maxBS = await trading.Trading.GetMaxBuySellAsync("YOUR_ACCOUNT_NO", "SSI", 66000);
Console.WriteLine($"Max buy: {maxBS.MaxBuyQuantity}");
Console.WriteLine($"Max sell: {maxBS.MaxSellQuantity}");

// At market price
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";

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

// Stop order (stop market)
var stop = await trading.Trading.PlaceFcoStopAsync(
    accountNo, "SSI", OrderSide.Sell, 100, 24000m, FCOOperator.LesserOrEqual, fromDate, toDate);

// Stop Limit order
var stopLimit = await trading.Trading.PlaceFcoStopLimitAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 25500, 0.5m, 25000m, FCOOperator.GreaterOrEqual, fromDate, toDate);

// Trailing Stop order
var trailing = await trading.Trading.PlaceFcoTrailingStopAsync(
    accountNo, "SSI", OrderSide.Buy, 100, 26000m, 1000m, fromDate, toDate);

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

// OCO order (one cancels the other)
var oco = await trading.Trading.PlaceFcoOcoAsync(
    accountNo, "SSI", OrderSide.Sell, 100, 30000m, 24000m, OrderType.MTL, OrderType.MTL, 0.5m, 0.5m, fromDate, toDate);

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

// Cancel a conditional order
var cancelRes = await trading.Trading.CancelFcoAsync(gtd.FCOID);

// Get all FCO orders for an account
var fcos = await trading.Trading.GetFcoByAccountNoAsync("YOUR_ACCOUNT_NO");

// Get FCO orders by symbol
var fcosBySymbol = await trading.Trading.GetFcoBySymbolAsync("YOUR_ACCOUNT_NO", "SSI");

// Get FCO orders by processing status
var fcosByStatus = await trading.Trading.GetFcoByStatusAsync("YOUR_ACCOUNT_NO", FCOStatus.Trit);

// Get FCO orders by date range
var fcosByDate = await trading.Trading.GetFcoByDateAsync("YOUR_ACCOUNT_NO", "2026/07/01", "2026/07/21");

// Get a single FCO order by ID
var fcoInfo = await trading.Trading.GetFcoByIdAsync("YOUR_ACCOUNT_NO", "fco-id-here");

// Get the order book / execution log for an FCO order
var orderBook = await trading.Trading.GetFcoOrderBookAsync("fco-id-here");

// Status history of an FCO order
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)
{
    // Empty batch, over the limit, or an invalid order: nothing was sent
    Console.WriteLine($"SDK rejected: {ex.Message}");
}
catch (DuplicateRequestException ex)
{
    Console.WriteLine($"Duplicate (409): {ex.Message}");
}
catch (RateLimitException ex)
{
    // The SDK does not resend POST; wait and decide yourself
    Console.WriteLine($"Rate limited, retry after {ex.RetryAfterMs} ms");
}
catch (AuthenticationException ex)
{
    Console.WriteLine($"Authentication/signature error: {ex.Message}");
}
catch (ApiException ex)
{
    Console.WriteLine($"API error [{ex.Code}] HTTP {ex.StatusCode}: {ex.Message}");
}

static async Task CancelPlacedAsync(TradingClient trading, BatchOrderResponse placed)
{
    // Prefer OrderId; otherwise use ClientRequestId. Exactly one identifier per item.
    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> built as in example 1
var limit = config.MaxBatchOrders;
foreach (var chunk in allItems.Chunk(limit))
{
    // Send one after another; let an exception stop the loop instead of blindly sending the rest.
    var resp = await trading.Trading.PlaceBatchOrdersAsync(chunk);
    var failed = resp.Results.Count(r => !r.Success);
    Console.WriteLine($"batch done: {resp.Results.Count} orders, {failed} failed");
}

using var stream = new StreamClient(auth);

await stream.ConnectAsync();       // Connect WebSocket

// Wait indefinitely
await stream.WaitAsync();

// Wait with timeout (milliseconds)
await stream.WaitAsync(timeoutMs: 30000);

await stream.DisconnectAsync();     // Manual disconnect (if not using `using`); a synchronous Disconnect() also exists

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

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

// All channels (trade + quote + room) for a symbol
await stream.Streaming.SubscribeSymbolAsync(["SSI", "HPG", "VIC"]);

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

// By board (@* fan-out, see the note below)
await stream.Streaming.SubscribeBoardAsync([Board.HOSE, Board.HNX]);

// By index (@* fan-out of the constituents, see the note below)
await stream.Streaming.SubscribeIndexAsync(["VNINDEX", "VN30"]);

// Master data (ceiling, floor, reference) of a symbol or board
await stream.Streaming.SubscribeMarketAsync(["SSI"]);

// Trading-session flag (ATO, LO, ATC, ...) of the boards
await stream.Streaming.SubscribeMarketFlagAsync();

// Ticks, candles and summary of the index itself: see 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"]);

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

// Unsubscribe everything and see what the server still holds
var removed = await stream.Streaming.UnsubscribeAllAsync();               // Dictionary<string, List<string>>
var active = await stream.Streaming.ListSubscriptionAsync(timeoutMs: 5000); // keys "trading" and "data"

// Order status (all accounts, default "*")
await stream.Streaming.SubscribeOrderStatusAsync();

// For a specific account
await stream.Streaming.SubscribeOrderStatusAsync("YOUR_ACCOUNT_NO");

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

// One-time ping
await stream.Streaming.PingAsync();

// Automatic recurring ping (milliseconds)
await stream.Streaming.PingAsync(intervalMs: 30000);

// Stop the automatic ping loop
stream.Streaming.StopPingLoop();

using SsiSdk;
using SsiSdk.Models;

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

stream.Streaming.OnData = msg =>
{
    switch (msg)
    {
        case IntervalMessage bar:
            Console.WriteLine($"[BAR] {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}%) adv/dec: {idx.Advances}/{idx.Declines}");
            break;
    }
};

await stream.ConnectAsync();

await stream.Streaming.SubscribeIndexTradeAsync(["VNINDEX", "VN30"]);       // ticks
await stream.Streaming.SubscribeIndexTradeAsync(["VNINDEX"], "1m");         // 1-minute candles

await stream.WaitAsync(60_000);   // listen for 60 seconds

await stream.Streaming.UnsubscribeIndexTradeAsync(["VNINDEX", "VN30"]);
await stream.Streaming.UnsubscribeIndexTradeAsync(["VNINDEX"], "1m");      // same interval as at subscribe time
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} topics");

var removed = await stream.Streaming.UnsubscribeAllAsync();
Console.WriteLine($"Removed {removed.Values.Sum(v => v.Count)} topics");

using SsiSdk;
using SsiSdk.Models;

await using var ws = await TradingWs.ConnectAsync(auth);
Console.WriteLine($"Connected: {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($"Events received: {events}");
}
catch (TradingWsError ex)
{
    // The server rejected the socket or a command
    Console.WriteLine($"Trading WS rejected: status={ex.Status} code={ex.ErrorCode} {ex.ServerMessage}");
}
catch (SsiException ex)
{
    Console.WriteLine($"Error: {ex.GetType().Name} [{ex.Code}] {ex.Message}");
}

var account = "YOUR_ACCOUNT_NO";
var clientRequestId = $"ws-{Guid.NewGuid().ToString("N")[..8]}";   // max 20 characters

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

    // Follow the real result on the order event stream
    ws.Client.OnEvent = _ => Console.WriteLine("order event received");
    await ws.SubscribeOrderEventsAsync(account);

    var placed = await ws.PlaceOrderAsync(
        account, "SSI", OrderSide.Buy, 100, 20000m, OrderType.LO, clientRequestId);
    Console.WriteLine("order.place acknowledged");

    // The acknowledgement may carry no orderId: cancel by clientRequestId
    var cancelled = await ws.CancelOrderAsync(account, clientRequestId: clientRequestId);
    Console.WriteLine("order.cancel acknowledged");
}
catch (TradingWsError ex)
{
    Console.WriteLine($"Rejected: status={ex.Status} code={ex.ErrorCode} {ex.ServerMessage}");
}
catch (ValidationException ex)
{
    Console.WriteLine($"Invalid input (nothing sent): {ex.Message}");
}
catch (WebSocketException ex)
{
    // Timeout, closed socket or missing PrivateKey. After a timeout the order may or may not have been created.
    Console.WriteLine($"WebSocket error: {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: the TradingWsService from ConnectAsync

// The result is raw JSON: print only the shape, then read the final status from order events
var kind = response.Result.ValueKind;
Console.WriteLine($"status={response.Status} method={response.Method} result={kind}");