API Services

const token = await auth.authenticate('YOUR_OTP');
console.log(`Token hết hạn lúc (epoch giây): ${token.expiresAt}`);

const token = await auth.authenticate(undefined, 'YOUR_TRANSACTION_ID');

// Kiểu lỏng: Record<string, unknown>
await auth.requestOtp();

// Kiểu rõ ràng: OTPResponse { message, transactionId? }
const otp = await auth.requestOtpTyped();
if (otp.transactionId) {
  // chỉ có với Smart OTP
  await auth.ensureAuthenticated(undefined, otp.transactionId);
}

const token = await auth.refresh();

await auth.ensureAuthenticated('YOUR_OTP');

const token = auth.getToken();
auth.setToken(token);

auth.isTokenExpired;   // boolean
auth.hasRefreshToken;  // boolean
auth.canRefresh;       // refresh token còn dùng được?

const accounts = await trading.account.getAccountInfo();

for (const acc of accounts) {
  console.log(`${acc.accountNo} (${acc.accountType ?? 'không rõ'})`);
}

const ohlc = await data.marketData.getOhlc1Minute('SSI');
for (const candle of ohlc) {
  console.log(`${candle.tradingDate}: O=${candle.openPrice} H=${candle.highPrice} L=${candle.lowPrice} C=${candle.closePrice} V=${candle.volume}`);
}

const ohlc = await data.marketData.getOhlc1DayHistorical(
  'SSI', '2026/03/27', '2026/04/22', 1, 100,
);

import { Timeframe } from '@ssi.developer/ssi-sdk';

for await (const bar of data.marketData.iterOhlc('SSI', Timeframe.DAY_1, '2026/03/01', '2026/03/31')) {
  console.log(bar.tradingDate, bar.closePrice);
}

const all = await data.marketData.getOhlcAll('SSI', Timeframe.DAY_1, '2026/03/01', '2026/03/31', 1000, true);

// Tất cả chỉ số
const indexes = await data.marketData.getIndexes();

// Theo sàn
import { Board } from '@ssi.developer/ssi-sdk';
const indexes = await data.marketData.getIndexesByBoard(Board.HOSE);

for (const idx of indexes) {
  console.log(`${idx.index} - ${idx.indexName}`);
}

// Tổng hợp hiện tại
const summary = await data.marketData.getIndexSummary('VNINDEX');

// Tổng hợp lịch sử
const summary = await data.marketData.getIndexSummaryHistorical('VNINDEX', '2026/01/15');

// Tổng hợp theo sàn
const summary = await data.marketData.getBoardSummary(Board.HOSE);

// Tổng hợp theo sàn lịch sử
const summary = await data.marketData.getBoardSummaryHistorical(Board.HOSE, '2026/01/15');

// Một mã
const info = await data.marketData.getSecuritiesInfo('SSI');

// Theo chỉ số
const securities = await data.marketData.getSecuritiesInfoByIndex('VN30');

// Theo sàn
const securities = await data.marketData.getSecuritiesInfoByBoard(Board.HOSE);

// Tổng hợp hiện tại
const summary = await data.marketData.getSecuritiesSummary('SSI');

// Tổng hợp lịch sử
const summary = await data.marketData.getSecuritiesSummaryHistorical(
  'SSI', '2026/03/01', '2026/03/31',
);

// Theo chỉ số
const summary = await data.marketData.getSecuritiesSummaryByIndex('VN30');

// Theo chỉ số lịch sử
const summary = await data.marketData.getSecuritiesSummaryByIndexHistorical(
  'VN30', '2026/03/01', '2026/03/31',
);

// Hôm nay
const master = await data.marketData.getMasterData();

// Theo khoảng ngày
const history = await data.marketData.getMasterDataHistorical('2026/03/01', '2026/03/31');

// Hôm nay (mọi mã, hoặc một mã)
const today = await data.marketData.getCorporateActions();
const one = await data.marketData.getCorporateActions('SSI', 'en');

// Quá khứ: khoảng ngày tối đa 5 ngày
const past = await data.marketData.getCorporateActionsHistorical(
  '2026/10/08',
  '2026/10/12',
  undefined, // undefined = tất cả mã
  'vn',      // 'vn' (mặc định) hoặc 'en'
);
for (const e of past) {
  console.log(e.symbol, e.eventTitle, e.exrightDate, e.recordDate, e.issueDate, e.exchange, e.ratio);
}

// Số dư cổ phiếu
const balance = await trading.portfolio.getEquityBalance('YOUR_ACCOUNT_NO');

// Số dư phái sinh
const derBalance = await trading.portfolio.getDerivativeBalance('YOUR_DERIVATIVE_ACCOUNT_NO');

// Vị thế cổ phiếu
const positions = await trading.portfolio.getEquityPositions('YOUR_ACCOUNT_NO');
for (const pos of positions ?? []) {
  console.log(`${pos.symbol}: ${pos.quantity} cổ | Giá vốn: ${pos.costPrice}`);
}

// Tất cả vị thế phái sinh
const derPositions = await trading.portfolio.getDerivativePositions('YOUR_DERIVATIVE_ACCOUNT_NO');

// Chỉ vị thế đang mở
const openPos = await trading.portfolio.getOpenDerivativePositions('YOUR_DERIVATIVE_ACCOUNT_NO');

// Chỉ vị thế đã đóng
const closedPos = await trading.portfolio.getClosedDerivativePositions('YOUR_DERIVATIVE_ACCOUNT_NO');

// Lệnh trong ngày
const orders = await trading.portfolio.getTodayOrders('YOUR_ACCOUNT_NO');
for (const order of orders) {
  console.log(`${order.orderId}: ${order.symbol} ${order.side} ${order.quantity}@${order.price} - ${order.status}`);
}

// Lệnh lịch sử
const orders = await trading.portfolio.getHistoricalOrders('YOUR_ACCOUNT_NO', '2026/01/01', '2026/01/31');

// PPMMR cổ phiếu
const ppmmr = await trading.portfolio.getEquityPpmmr('YOUR_ACCOUNT_NO');

// PPMMR phái sinh
const derPPMMR = await trading.portfolio.getDerivativePpmmr('YOUR_DERIVATIVE_ACCOUNT_NO');

import { OrderSide, OrderType } from '@ssi.developer/ssi-sdk';

// Lệnh giới hạn (LO)
const result = await trading.trading.placeLimitOrder('YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100, 66000);

// Lệnh thị trường (MTL)
const result = await trading.trading.placeMarketOrder('YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100);

// Lệnh ATO (mở cửa)
const result = await trading.trading.placeAtoOrder('YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100);

// Lệnh ATC (đóng cửa)
const result = await trading.trading.placeAtcOrder('YOUR_ACCOUNT_NO', 'SSI', OrderSide.SELL, 100);

// Loại lệnh tuỳ chỉnh
const result = await trading.trading.placeOrder(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100, 66000, OrderType.LO,
);

console.log(`Order ID: ${result.orderId}, Status: ${result.status}`);

// Sửa giá theo clientRequestId
const result = await trading.trading.modifyOrderPrice('YOUR_ACCOUNT_NO', 'YOUR_CLIENT_REQUEST_ID', 68000);

// Sửa giá theo orderId
const result = await trading.trading.modifyOrderPriceByOrderId('YOUR_ACCOUNT_NO', 'YOUR_ORDER_ID', 68000);

// Sửa khối lượng theo clientRequestId
const result = await trading.trading.modifyOrderQuantity('YOUR_ACCOUNT_NO', 'YOUR_CLIENT_REQUEST_ID', 200);

// Sửa khối lượng theo orderId
const result = await trading.trading.modifyOrderQuantityByOrderId('YOUR_ACCOUNT_NO', 'YOUR_ORDER_ID', 200);

// Huỷ theo clientRequestId
const result = await trading.trading.cancelOrder('YOUR_ACCOUNT_NO', 'YOUR_CLIENT_REQUEST_ID');

// Huỷ theo orderId
const result = await trading.trading.cancelOrderById('YOUR_ACCOUNT_NO', 'YOUR_ORDER_ID');

// Với giá cụ thể
const maxBS = await trading.trading.getMaxBuySell('YOUR_ACCOUNT_NO', 'SSI', 66000);
console.log(`Max mua: ${maxBS.maxBuyQuantity}, Max bán: ${maxBS.maxSellQuantity}`);

// Theo giá thị trường
const maxBS = await trading.trading.getMaxBuySellAtMarketPrice('YOUR_ACCOUNT_NO', 'SSI');

import { FCOOperator, OrderSide, OrderType, fromBeginningOfDay, fromEndOfDay } from '@ssi.developer/ssi-sdk';

const fromDate = fromBeginningOfDay(); // "YYYY/MM/DD 00:00:00"
const toDate = fromEndOfDay();         // "YYYY/MM/DD 23:59:59"

// Lệnh GTD (Good Till Date)
const gtd = await trading.trading.placeFcoGtd(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100, 25000, 500, fromDate, toDate,
);
console.log(`FCO ID: ${gtd.fcoId}`);

// Lệnh Stop Market
const stop = await trading.trading.placeFcoStop(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.SELL, 100, 24000, FCOOperator.LESSER_OR_EQUAL, fromDate, toDate,
);

// Lệnh Stop Limit
const stopLimit = await trading.trading.placeFcoStopLimit(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100, 25500, 500, 25000, FCOOperator.GREATER_OR_EQUAL, fromDate, toDate,
);

// Lệnh Trailing Stop
const trailing = await trading.trading.placeFcoTrailingStop(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.BUY, 100, 26000, 1000, fromDate, toDate,
);

// Lệnh OCO (One-Cancels-the-Other)
const oco = await trading.trading.placeFcoOco(
  'YOUR_ACCOUNT_NO', 'SSI', OrderSide.SELL, 100, 30000, 24000, OrderType.MTL, OrderType.MTL, 500, 500, fromDate, toDate,
);

// Tra cứu danh sách lệnh FCO theo tài khoản
const fcoList = await trading.trading.getFcoByAccountNo('YOUR_ACCOUNT_NO', 1, 10);
console.log(`FCO items: ${fcoList.fcoList.length}`);

// Lịch sử trạng thái của một lệnh FCO (mảng rỗng nếu chưa có)
const history = await trading.trading.getFcoStatusHistory(gtd.fcoId);

// Huỷ lệnh FCO
await trading.trading.cancelFco(gtd.fcoId);

import {
  Auth, Config, Trading, OrderSide, OrderType,
  DuplicateRequestError, ValidationError,
} from '@ssi.developer/ssi-sdk';

const config = new Config({
  clientId: 'YOUR_CLIENT_ID',
  apiKey: 'YOUR_API_KEY',
  apiSecret: 'YOUR_API_SECRET',
  privateKey: 'YOUR_PRIVATE_KEY',
});

const auth = new Auth(config);
await auth.authenticate('YOUR_OTP'); // OTP của bạn
const trading = new Trading(auth);

const accountNo = 'YOUR_ACCOUNT_NO';
const tag = Date.now().toString(36); // clientRequestId tối đa 20 ký tự

const items = [
  { accountNo, symbol: 'SSI', side: OrderSide.BUY, quantity: 100, price: '25.5', orderType: OrderType.LO, clientRequestId: `b${tag}-1` },
  { accountNo, symbol: 'VNM', side: OrderSide.BUY, quantity: 100, price: '60', orderType: OrderType.LO, clientRequestId: `b${tag}-2` },
];

try {
  const response = await trading.trading.placeBatchOrders(items);
  console.log(`Batch: ${response.batchRequestId}`);

  for (const r of response.results) {
    if (r.success) {
      console.log(`OK  ${r.clientRequestId} -> orderId ${r.orderId}, status ${r.status}`);
    } else {
      console.log(`LOI ${r.clientRequestId}: ${r.errorCode} ${r.errorMessage}`);
    }
  }
} catch (error) {
  if (error instanceof ValidationError) {
    console.error(`Lô không hợp lệ, chưa có request nào được gửi: ${error.message}`);
  } else if (error instanceof DuplicateRequestError) {
    // Id đã dùng trong ngày: lệnh gốc có thể vẫn đang sống. Kiểm tra sổ lệnh, đừng gửi lại bằng id khác.
    console.error(`Trùng id (HTTP 409): ${error.message}`);
  } else {
    throw error;
  }
}

const accepted = response.results.filter((r) => r.success && r.orderId);

if (accepted.length > 0) {
  const cancelled = await trading.trading.cancelBatchOrders(
    accepted.map((r) => ({ accountNo, orderId: r.orderId })),
  );

  for (const r of cancelled.results) {
    console.log(`${r.success ? 'OK ' : 'LOI'} orderId ${r.orderId} | ${r.status} ${r.errorCode} ${r.errorMessage}`);
  }
}

const stream = new Stream(auth);

await stream.streaming.connect();

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

// Hoặc chờ tối đa 60 giây
await stream.streaming.wait(60_000);

stream.streaming.onData = (msg) => {
  console.log('[DATA]', msg);
};

stream.streaming.onTrading = (msg) => {
  console.log('[TRADING]', msg);
};

stream.streaming.onHeartbeat = (msg) => {
  console.log('[HEARTBEAT]', msg);
};

import { Board, Timeframe } from '@ssi.developer/ssi-sdk';

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

// Kênh riêng lẻ
await stream.streaming.subscribeSymbolTrade(['SSI', 'HPG']);
await stream.streaming.subscribeSymbolQuote(['SSI', 'HPG']);
await stream.streaming.subscribeSymbolRoom(['SSI', 'HPG']);
await stream.streaming.subscribeSymbolPutThrough(['SSI']);
await stream.streaming.subscribeSymbolOddLot(['SSI']);

// OHLCV theo timeframe (chỉ tick, 1m, 5m)
await stream.streaming.subscribeSymbolOhlcv(['SSI'], Timeframe.MINUTE_1);

// Theo sàn
await stream.streaming.subscribeBoard([Board.HOSE, Board.HNX]);

// Theo chỉ số (cổ phiếu thành phần)
await stream.streaming.subscribeIndex(['VNINDEX', 'VN30']);

// Cờ phiên thị trường và master data
await stream.streaming.subscribeMarketFlag();
await stream.streaming.subscribeMarket(['SSI']);

await stream.streaming.unsubscribeSymbol(['SSI', 'HPG']);
await stream.streaming.unsubscribeSymbolTrade(['SSI']);
await stream.streaming.unsubscribeSymbolQuote(['SSI']);
await stream.streaming.unsubscribeSymbolRoom(['SSI']);
await stream.streaming.unsubscribeSymbolPutThrough(['SSI']);
await stream.streaming.unsubscribeSymbolOddLot(['SSI']);
await stream.streaming.unsubscribeSymbolOhlcv(['SSI'], Timeframe.MINUTE_1);
await stream.streaming.unsubscribeBoard([Board.HOSE]);
await stream.streaming.unsubscribeIndex(['VNINDEX']);

// Trạng thái lệnh (thường + FCO) — tất cả tài khoản
await stream.streaming.subscribeOrderStatus();

// Cho tài khoản cụ thể
await stream.streaming.subscribeOrderStatus('YOUR_ACCOUNT_NO');

// Danh mục — tất cả tài khoản
await stream.streaming.subscribePortfolio();

// Cho tài khoản cụ thể
await stream.streaming.subscribePortfolio('YOUR_ACCOUNT_NO');

// Hủy
await stream.streaming.unsubscribeOrderStatus('YOUR_ACCOUNT_NO');
await stream.streaming.unsubscribePortfolio('YOUR_ACCOUNT_NO');

await stream.streaming.ping();

// Hoặc bật vòng ping nền mỗi 30 giây
await stream.streaming.ping(undefined, 30_000);

import { Auth, Config, Stream } from '@ssi.developer/ssi-sdk';
import type { DataMessage, IndexTickMessage } from '@ssi.developer/ssi-sdk';

const config = new Config({
  clientId: 'YOUR_CLIENT_ID',
  apiKey: 'YOUR_API_KEY',
  apiSecret: 'YOUR_API_SECRET',
});

const auth = new Auth(config);
await auth.authenticate('YOUR_OTP'); // OTP của bạn

const stream = new Stream(auth);
const s = stream.streaming;

// Chỉ IndexTickMessage có field `raw`
const isIndexTick = (msg: DataMessage): msg is IndexTickMessage => 'raw' in msg;

s.onConnection = (event) => {
  console.log(`[CONNECTION] ${event.state} | reconnectCount: ${event.reconnectCount}` +
    (event.error ? ` | lỗi: ${event.error.message}` : ''));
};

s.onData = (msg) => {
  if (isIndexTick(msg)) {
    console.log(`[INDEX] ${msg.symbol} ${msg.value} (${msg.change}, ${msg.changePercent}%)`);
  }
};

s.onIndexSummary = (msg) => {
  console.log(`[SUMMARY] ${msg.index} | ${Object.keys(msg.data).length} field`);
};

await s.connect();
await s.subscribeIndexTrade(['VNINDEX', 'VN30']);
await s.subscribeIndexSummary(['VNINDEX']);
await s.ping(undefined, 30_000); // SDK không tự ping, bật vòng ping nền

await s.wait(60_000); // nhận dữ liệu trong 60 giây

await s.unsubscribeIndexTrade(['VNINDEX', 'VN30']);
await s.unsubscribeIndexSummary(['VNINDEX']);
await stream.disconnect();

import { Timeframe } from '@ssi.developer/ssi-sdk';
import type { IntervalMessage } from '@ssi.developer/ssi-sdk';

const INDICES = ['VN30'];

s.onData = (msg) => {
  // Nến có field intervalTime. Lọc theo symbol để chỉ lấy nến chỉ số
  if ('intervalTime' in msg && INDICES.includes((msg as IntervalMessage).symbol)) {
    const c = msg as IntervalMessage;
    console.log(`[CANDLE] ${c.symbol} ${c.intervalTime} O${c.open} H${c.high} L${c.low} C${c.close} V${c.volume}`);
  }
};

await s.subscribeIndexTrade(INDICES, Timeframe.MINUTE_1);

const subs = await s.listSubscription();
console.log(`data topics: ${subs.data.join(', ')}`);

// ... sau khi dùng xong ...
await s.unsubscribeIndexTrade(INDICES, Timeframe.MINUTE_1); // cùng interval đã subscribe

import { Auth, Config, asyncTradingWs, TradingWSError } from '@ssi.developer/ssi-sdk';

const config = new Config({
  clientId: 'YOUR_CLIENT_ID',
  apiKey: 'YOUR_API_KEY',
  apiSecret: 'YOUR_API_SECRET',
  privateKey: 'YOUR_PRIVATE_KEY',
});

const auth = new Auth(config);
await auth.ensureAuthenticated('YOUR_OTP'); // OTP của bạn

const ws = await asyncTradingWs(auth); // kết nối tới Config.tradingWsUrl
// ... dùng ws ...
await ws.close();

import { Auth, Config, asyncTradingWs, TradingWSError } from '@ssi.developer/ssi-sdk';

const config = new Config({
  clientId: 'YOUR_CLIENT_ID',
  apiKey: 'YOUR_API_KEY',
  apiSecret: 'YOUR_API_SECRET',
  privateKey: 'YOUR_PRIVATE_KEY',
});
const auth = new Auth(config);
await auth.ensureAuthenticated('YOUR_OTP'); // OTP của bạn

const accountNo = 'YOUR_ACCOUNT_NO';

let ws;
try {
  ws = await asyncTradingWs(auth);
} catch (error) {
  // Môi trường có thể chưa hỗ trợ trading WebSocket: dùng REST thay thế
  console.error(`Không kết nối được: ${error.message}`);
  process.exit(1);
}

// Frame không gắn với command nào (sự kiện lệnh, danh mục, pong...) đi vào onEvent.
// Frame là object thô, SDK không parse thành model.
ws.client.onEvent = (frame) => {
  console.log('[EVENT]', frame);
};

try {
  await ws.subscribeOrderEvents(accountNo);
  await ws.subscribePortfolioEvents(accountNo);

  const position = await ws.queryPosition(accountNo, true);
  console.log(`position: status ${position.status}`, position.result);

  const max = await ws.queryMaxBuySell(accountNo, 'SSI'); // không truyền price: server dùng giá tham chiếu
  console.log(`maxBuySell: status ${max.status}`, max.result);

  const book = await ws.queryOrderBook(accountNo, { pageIndex: 1, pageSize: 10 });
  console.log(`orderBook: status ${book.status}`, book.result);
} catch (error) {
  if (error instanceof TradingWSError) {
    console.error(`Server từ chối: status=${error.status} code=${error.errorCode} msg=${error.serverMessage}`);
  } else {
    console.error(`Lỗi: ${error.message}`);
  }
} finally {
  await ws.unsubscribeAllEvents().catch(() => undefined);
  await ws.close();
}

import { OrderSide, OrderType } from '@ssi.developer/ssi-sdk';

const clientRequestId = `w${Date.now().toString(36)}`; // tối đa 20 ký tự

const ack = await ws.placeOrder(
  accountNo, 'SSI', OrderSide.BUY, 100, '25.5', OrderType.LO, clientRequestId,
);
console.log(`Ack: orderId ${ack.orderId || '-'} | status ${ack.status}`); // ack, status PD
console.log('rateLimit:', ws.client.rateLimit);

// Kết quả thật của lệnh đến qua ws.client.onEvent (đã subscribeOrderEvents)
if (ack.orderId) {
  const cancelled = await ws.cancelOrder(accountNo, ack.orderId);
  console.log(`Hủy: status ${cancelled.status}`);
}