hft-js 0.2.0 → 0.4.0

package/src/trader.ts

@@ -1,7 +1,7 @@
 /*
  * trader.ts
  *
- * Copyright (c) 2025 Xiongfei Shi
+ * Copyright (c) 2025-2026 Xiongfei Shi
  *
  * Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
  * License: Apache-2.0
@@ -10,14 +10,36 @@
  */
 
 import Denque from "denque";
-import ctp from "napi-ctp";
+import ctp, { type Trader as TraderApi } from "napi-ctp";
+import type {
+  DepthMarketDataField,
+  DirectionType,
+  InputOrderActionField,
+  InputOrderField,
+  InstrumentCommissionRateField,
+  InstrumentField,
+  InstrumentMarginRateField,
+  InvestorPositionDetailField,
+  InvestorPositionField,
+  OffsetFlagType,
+  OptionsTypeType,
+  OrderField,
+  OrderPriceTypeType,
+  ProductClassType,
+  RspAuthenticateField,
+  RspUserLoginField,
+  SettlementInfoConfirmField,
+  TradeField,
+  TradingAccountField,
+} from "@napi-ctp/types";
 import { CTPProvider } from "./provider.js";
 import { isValidPrice, parseSymbol } from "./utils.js";
-import {
+import type {
   CommissionRate,
   InstrumentData,
   MarginRate,
   OffsetType,
+  OptionsType,
   OrderData,
   OrderFlag,
   OrderStatistic,
@@ -32,9 +54,10 @@ import {
   TradingAccount,
   Writeable,
 } from "./typedef.js";
-import {
+import type {
   ICancelOrderResultReceiver,
   ICommissionRateReceiver,
+  IErrorReceiver,
   IInstrumentReceiver,
   IInstrumentsReceiver,
   ILifecycleListener,
@@ -89,7 +112,7 @@ export type TraderOptions = {
 };
 
 export class Trader extends CTPProvider implements ITraderProvider {
-  private traderApi?: ctp.Trader;
+  private traderApi?: TraderApi;
   private tradingDay: number;
   private frontId: number;
   private sessionId: number;
@@ -99,14 +122,14 @@ export class Trader extends CTPProvider implements ITraderProvider {
   private readonly fastQueryLastTick?: FastQueryLastTickFunc;
   private readonly userInfo: CTPUserInfo;
   private readonly receivers: IOrderReceiver[];
-  private readonly accounts: ctp.TradingAccountField[];
-  private readonly positionDetails: ctp.InvestorPositionDetailField[];
-  private readonly instruments: Map<string, ctp.InstrumentField>;
+  private readonly accounts: TradingAccountField[];
+  private readonly positionDetails: InvestorPositionDetailField[];
+  private readonly instruments: Map<string, InstrumentField>;
   private readonly positions: Map<string, PositionInfo>;
-  private readonly orders: Map<string, ctp.OrderField>;
-  private readonly trades: Map<string, ctp.TradeField[]>;
-  private readonly marginRates: Map<string, ctp.InstrumentMarginRateField>;
-  private readonly commRates: Map<string, ctp.InstrumentCommissionRateField>;
+  private readonly orders: Map<string, OrderField>;
+  private readonly trades: Map<string, TradeField[]>;
+  private readonly marginRates: Map<string, InstrumentMarginRateField>;
+  private readonly commRates: Map<string, InstrumentCommissionRateField>;
   private readonly placeOrders: Map<number, IPlaceOrderResultReceiver>;
   private readonly cancelOrders: Map<number, ICancelOrderResultReceiver>;
   private readonly marketOrdersQueue: Map<string, Denque<MarketOrder>>;
@@ -155,7 +178,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  open(lifecycle: ILifecycleListener) {
+  open(lifecycle: ILifecycleListener, errorReceiver: IErrorReceiver) {
     if (this.traderApi) {
       return true;
     }
@@ -172,10 +195,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       this.cancelOrders.clear();
     });
 
-    this.traderApi.on<ctp.RspAuthenticateField>(
+    this.traderApi.on<RspAuthenticateField>(
       ctp.TraderEvent.RspAuthenticate,
       (_, options) => {
-        if (this._isErrorResp(lifecycle, options, "login-error")) {
+        if (this._isErrorResp(errorReceiver, options, "login-error")) {
           return;
         }
 
@@ -183,10 +206,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.RspUserLoginField>(
+    this.traderApi.on<RspUserLoginField>(
       ctp.TraderEvent.RspUserLogin,
       (rspUserLogin, options) => {
-        if (this._isErrorResp(lifecycle, options, "login-error")) {
+        if (this._isErrorResp(errorReceiver, options, "login-error")) {
           return;
         }
 
@@ -210,10 +233,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.SettlementInfoConfirmField>(
+    this.traderApi.on<SettlementInfoConfirmField>(
       ctp.TraderEvent.RspSettlementInfoConfirm,
       (_, options) => {
-        if (this._isErrorResp(lifecycle, options, "login-error")) {
+        if (this._isErrorResp(errorReceiver, options, "login-error")) {
           return;
         }
 
@@ -222,10 +245,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.OrderField>(
+    this.traderApi.on<OrderField>(
       ctp.TraderEvent.RspQryOrder,
       (order, options) => {
-        if (this._isErrorResp(lifecycle, options, "query-order-error")) {
+        if (this._isErrorResp(errorReceiver, options, "query-order-error")) {
           return;
         }
 
@@ -241,10 +264,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.TradeField>(
+    this.traderApi.on<TradeField>(
       ctp.TraderEvent.RspQryTrade,
       (trade, options) => {
-        if (this._isErrorResp(lifecycle, options, "query-trade-error")) {
+        if (this._isErrorResp(errorReceiver, options, "query-trade-error")) {
           return;
         }
 
@@ -266,10 +289,12 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.InstrumentField>(
+    this.traderApi.on<InstrumentField>(
       ctp.TraderEvent.RspQryInstrument,
       (instrument, options) => {
-        if (this._isErrorResp(lifecycle, options, "query-instrument-error")) {
+        if (
+          this._isErrorResp(errorReceiver, options, "query-instrument-error")
+        ) {
           return;
         }
 
@@ -294,10 +319,12 @@ export class Trader extends CTPProvider implements ITraderProvider {
 
     let fired = false;
 
-    this.traderApi.on<ctp.InvestorPositionField>(
+    this.traderApi.on<InvestorPositionField>(
       ctp.TraderEvent.RspQryInvestorPosition,
       (position, options) => {
-        if (this._isErrorResp(lifecycle, options, "query-positions-error")) {
+        if (
+          this._isErrorResp(errorReceiver, options, "query-positions-error")
+        ) {
           return;
         }
 
@@ -362,7 +389,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.OrderField>(ctp.TraderEvent.RtnOrder, (order) => {
+    this.traderApi.on<OrderField>(ctp.TraderEvent.RtnOrder, (order) => {
       const orderId = this._calcOrderId(order);
       const current = this.orders.get(orderId);
 
@@ -469,7 +496,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
       }
     });
 
-    this.traderApi.on<ctp.TradeField>(ctp.TraderEvent.RtnTrade, (trade) => {
+    this.traderApi.on<TradeField>(ctp.TraderEvent.RtnTrade, (trade) => {
       const orderId = this._calcOrderId(trade);
       const trades = this.trades.get(orderId);
 
@@ -503,12 +530,14 @@ export class Trader extends CTPProvider implements ITraderProvider {
       }
     });
 
-    this.traderApi.on<ctp.InstrumentMarginRateField>(
+    this.traderApi.on<InstrumentMarginRateField>(
       ctp.TraderEvent.RspQryInstrumentMarginRate,
       (marginRate, options) => {
         const query = this.marginRatesQueue.shift();
 
-        if (this._isErrorResp(lifecycle, options, "query-margin-rate-error")) {
+        if (
+          this._isErrorResp(errorReceiver, options, "query-margin-rate-error")
+        ) {
           if (query) {
             query.receiver.onMarginRate(undefined);
           }
@@ -530,13 +559,17 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.InstrumentCommissionRateField>(
+    this.traderApi.on<InstrumentCommissionRateField>(
       ctp.TraderEvent.RspQryInstrumentCommissionRate,
       (commRate, options) => {
         const query = this.commRatesQueue.shift();
 
         if (
-          this._isErrorResp(lifecycle, options, "query-commission-rate-error")
+          this._isErrorResp(
+            errorReceiver,
+            options,
+            "query-commission-rate-error",
+          )
         ) {
           if (query) {
             query.receiver.onCommissionRate(undefined);
@@ -559,10 +592,10 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.TradingAccountField>(
+    this.traderApi.on<TradingAccountField>(
       ctp.TraderEvent.RspQryTradingAccount,
       (account, options) => {
-        if (this._isErrorResp(lifecycle, options, "query-accounts-error")) {
+        if (this._isErrorResp(errorReceiver, options, "query-accounts-error")) {
           const receivers = this.accountsQueue.toArray();
 
           receivers.forEach((receiver) =>
@@ -589,11 +622,15 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.InvestorPositionDetailField>(
+    this.traderApi.on<InvestorPositionDetailField>(
       ctp.TraderEvent.RspQryInvestorPositionDetail,
       (positionDetail, options) => {
         if (
-          this._isErrorResp(lifecycle, options, "query-position-details-error")
+          this._isErrorResp(
+            errorReceiver,
+            options,
+            "query-position-details-error",
+          )
         ) {
           const receivers = this.positionDetailsQueue.toArray();
 
@@ -626,7 +663,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.InputOrderField>(
+    this.traderApi.on<InputOrderField>(
       ctp.TraderEvent.RspOrderInsert,
       (order, options) => {
         if (options.rspInfo && order && options.requestId && options.isLast) {
@@ -643,7 +680,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.InputOrderActionField>(
+    this.traderApi.on<InputOrderActionField>(
       ctp.TraderEvent.RspOrderAction,
       (order, options) => {
         if (options.rspInfo && order && options.requestId && options.isLast) {
@@ -660,11 +697,15 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
-    this.traderApi.on<ctp.DepthMarketDataField>(
+    this.traderApi.on<DepthMarketDataField>(
       ctp.TraderEvent.RspQryDepthMarketData,
       (depthMarketData, options) => {
         if (
-          this._isErrorResp(lifecycle, options, "query-depth-market-data-error")
+          this._isErrorResp(
+            errorReceiver,
+            options,
+            "query-depth-market-data-error",
+          )
         ) {
           this._clearAllMarketOrders();
           return;
@@ -732,7 +773,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     return true;
   }
 
-  close(lifecycle: ILifecycleListener) {
+  close(lifecycle: ILifecycleListener, _errorReceiver: IErrorReceiver) {
     if (!this.traderApi) {
       return;
     }
@@ -1179,6 +1220,11 @@ export class Trader extends CTPProvider implements ITraderProvider {
     flag: OrderFlag,
     receiver: IPlaceOrderResultReceiver,
   ) {
+    if (volume <= 0) {
+      receiver.onPlaceOrderError("Invalid Volume");
+      return;
+    }
+
     switch (flag) {
       case "limit":
         return this._placeLimitOrder(
@@ -1241,19 +1287,16 @@ export class Trader extends CTPProvider implements ITraderProvider {
     return `${instrument.InstrumentID}.${instrument.ExchangeID}`;
   }
 
-  private _calcOrderId(orderOrTrade: ctp.OrderField | ctp.TradeField) {
+  private _calcOrderId(orderOrTrade: OrderField | TradeField) {
     const { ExchangeID, TraderID, OrderLocalID } = orderOrTrade;
     return `${ExchangeID}:${TraderID}:${OrderLocalID}`;
   }
 
-  private _calcReceiptId(order: ctp.OrderField | ctp.InputOrderActionField) {
+  private _calcReceiptId(order: OrderField | InputOrderActionField) {
     return `${order.FrontID}:${order.SessionID}:${parseInt(order.OrderRef)}`;
   }
 
-  private _calcOrderStatus(
-    order: ctp.OrderField,
-    traded?: number,
-  ): OrderStatus {
+  private _calcOrderStatus(order: OrderField, traded?: number): OrderStatus {
     switch (order.OrderStatus) {
       case ctp.OrderStatusType.Unknown:
         return "submitted";
@@ -1279,7 +1322,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  private _calcOrderFlag(orderPriceType: ctp.OrderPriceTypeType): OrderFlag {
+  private _calcOrderFlag(orderPriceType: OrderPriceTypeType): OrderFlag {
     switch (orderPriceType) {
       case ctp.OrderPriceTypeType.LimitPrice:
         return "limit";
@@ -1289,7 +1332,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  private _calcSideType(direction: ctp.DirectionType): SideType {
+  private _calcSideType(direction: DirectionType): SideType {
     switch (direction) {
       case ctp.DirectionType.Buy:
         return "long";
@@ -1309,7 +1352,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  private _calcOffsetType(offset: ctp.OffsetFlagType): OffsetType {
+  private _calcOffsetType(offset: OffsetFlagType): OffsetType {
     switch (offset) {
       case ctp.OffsetFlagType.Open:
         return "open";
@@ -1335,7 +1378,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  private _calcProductType(productClass: ctp.ProductClassType): ProductType {
+  private _calcProductType(productClass: ProductClassType): ProductType {
     switch (productClass) {
       case ctp.ProductClassType.Futures:
         return "futures";
@@ -1343,11 +1386,32 @@ export class Trader extends CTPProvider implements ITraderProvider {
       case ctp.ProductClassType.Options:
         return "options";
 
+      case ctp.ProductClassType.Spot:
+        return "spot";
+
+      case ctp.ProductClassType.SpotOption:
+        return "spot-options";
+
       default:
         throw new Error(`Unsupported product class: ${productClass}`);
     }
   }
 
+  private _calcOptionsType(
+    optionsType: OptionsTypeType,
+  ): OptionsType | undefined {
+    switch (optionsType) {
+      case ctp.OptionsTypeType.CallOptions:
+        return "call";
+
+      case ctp.OptionsTypeType.PutOptions:
+        return "put";
+
+      default:
+        return undefined;
+    }
+  }
+
   private _ensurePositionInfo(symbol: string): PositionInfo {
     let position = this.positions.get(symbol);
 
@@ -1671,7 +1735,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     }
   }
 
-  private _toTradeData(trade: ctp.TradeField): TradeData {
+  private _toTradeData(trade: TradeField): TradeData {
     return Object.freeze({
       id: trade.TradeID,
       date: parseInt(trade.TradeDate),
@@ -1681,7 +1745,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
   }
 
-  private _toOrderData(order: ctp.OrderField): OrderData {
+  private _toOrderData(order: OrderField): OrderData {
     const orderId = this._calcOrderId(order);
     const trades = this.trades.get(orderId) ?? [];
 
@@ -1697,7 +1761,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
       time: this._parseTime(order.InsertTime),
       flag: this._calcOrderFlag(order.OrderPriceType),
       side: this._calcSideType(order.Direction),
-      offset: this._calcOffsetType(order.CombOffsetFlag as ctp.OffsetFlagType),
+      offset: this._calcOffsetType(order.CombOffsetFlag as OffsetFlagType),
       price: order.LimitPrice,
       volume: order.VolumeTotalOriginal,
       traded: traded,
@@ -1708,7 +1772,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
   }
 
-  private _toInstrumentData(instrument: ctp.InstrumentField): InstrumentData {
+  private _toInstrumentData(instrument: InstrumentField): InstrumentData {
     return Object.freeze({
       symbol: `${instrument.InstrumentID}.${instrument.ExchangeID}`,
       id: instrument.InstrumentID,
@@ -1724,12 +1788,14 @@ export class Trader extends CTPProvider implements ITraderProvider {
       priceTick: instrument.PriceTick,
       maxLimitOrderVolume: instrument.MaxLimitOrderVolume,
       minLimitOrderVolume: instrument.MinLimitOrderVolume,
+      strikePrice: instrument.StrikePrice,
+      optionsType: this._calcOptionsType(instrument.OptionsType),
     });
   }
 
   private _toCommissionRate(
     symbol: string,
-    commRate: ctp.InstrumentCommissionRateField,
+    commRate: InstrumentCommissionRateField,
   ): CommissionRate {
     return Object.freeze({
       symbol: symbol,
@@ -1750,7 +1816,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
 
   private _toMarginRate(
     symbol: string,
-    marginRate: ctp.InstrumentMarginRateField,
+    marginRate: InstrumentMarginRateField,
   ): MarginRate {
     return Object.freeze({
       symbol: symbol,
@@ -1765,11 +1831,12 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
   }
 
-  private _toTradingAccount(account: ctp.TradingAccountField): TradingAccount {
+  private _toTradingAccount(account: TradingAccountField): TradingAccount {
     return Object.freeze({
       id: account.AccountID,
       currency: account.CurrencyID,
       preBalance: account.PreBalance - account.Withdraw + account.Deposit,
+      preMargin: account.PreMargin,
       balance: account.Balance,
       cash: account.Available,
       margin: account.CurrMargin,
@@ -1781,7 +1848,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
   }
 
   private _toPositionDetail(
-    positionDetail: ctp.InvestorPositionDetailField,
+    positionDetail: InvestorPositionDetailField,
   ): PositionDetail {
     return Object.freeze({
       symbol: this._toSymbol(positionDetail.InstrumentID)!,

package/src/typedef.ts

@@ -1,7 +1,7 @@
 /*
  * typedef.ts
  *
- * Copyright (c) 2025 Xiongfei Shi
+ * Copyright (c) 2025-2026 Xiongfei Shi
  *
  * Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
  * License: Apache-2.0
@@ -168,6 +168,7 @@ export type TradingAccount = Readonly<{
   id: string;
   currency: string;
   preBalance: number;
+  preMargin: number;
   balance: number;
   cash: number;
   margin: number;
@@ -177,7 +178,8 @@ export type TradingAccount = Readonly<{
   frozenCommission: number;
 }>;
 
-export type ProductType = "futures" | "options";
+export type ProductType = "futures" | "options" | "spot" | "spot-options";
+export type OptionsType = "call" | "put";
 
 export type InstrumentData = Readonly<{
   symbol: string;
@@ -194,6 +196,8 @@ export type InstrumentData = Readonly<{
   priceTick: number;
   maxLimitOrderVolume: number;
   minLimitOrderVolume: number;
+  strikePrice: number;
+  optionsType?: OptionsType;
 }>;
 
 export type PriceVolume = Readonly<{

package/src/utils.ts

@@ -1,7 +1,7 @@
 /*
  * utils.ts
  *
- * Copyright (c) 2025 Xiongfei Shi
+ * Copyright (c) 2025-2026 Xiongfei Shi
  *
  * Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
  * License: Apache-2.0
@@ -9,9 +9,9 @@
  * https://github.com/shixiongfei/hft.js
  */
 
-import { BarData, OrderFlag } from "./typedef.js";
-import { BarInfo } from "./bar.js";
-import {
+import type { BarData, OrderFlag } from "./typedef.js";
+import type { BarInfo } from "./bar.js";
+import type {
   IPlaceOrderResultReceiver,
   IRuntimeEngine,
   IStrategy,
@@ -21,7 +21,7 @@ export const isValidPrice = (x: number) => x !== Number.MAX_VALUE && x !== 0;
 export const isValidVolume = (x: number) => x !== Number.MAX_VALUE && x !== 0;
 
 export const parseSymbol = (symbol: string): [string, string] => {
-  const [instrumentId, exchangeId] = symbol.split(".");
+  const [instrumentId = "", exchangeId = ""] = symbol.split(".");
   return [instrumentId, exchangeId];
 };
 
@@ -40,28 +40,28 @@ export const mergeBarData = (bars: BarData[]): BarData => {
   }
 
   if (bars.length === 1) {
-    return bars[1];
+    return bars[1]!;
   }
 
   const bar: BarInfo = {
-    symbol: bars[0].symbol,
-    date: bars[0].date,
-    time: bars[0].time,
-    openInterest: bars[0].openInterest,
-    openPrice: bars[0].openPrice,
-    highPrice: bars[0].highPrice,
-    lowPrice: bars[0].lowPrice,
-    closePrice: bars[0].closePrice,
-    volume: bars[0].volume,
-    amount: bars[0].volume,
-    delta: bars[0].delta,
-    poc: bars[0].poc,
-    buyVolumes: { ...bars[0].buyVolumes },
-    sellVolumes: { ...bars[0].sellVolumes },
+    symbol: bars[0]!.symbol,
+    date: bars[0]!.date,
+    time: bars[0]!.time,
+    openInterest: bars[0]!.openInterest,
+    openPrice: bars[0]!.openPrice,
+    highPrice: bars[0]!.highPrice,
+    lowPrice: bars[0]!.lowPrice,
+    closePrice: bars[0]!.closePrice,
+    volume: bars[0]!.volume,
+    amount: bars[0]!.volume,
+    delta: bars[0]!.delta,
+    poc: bars[0]!.poc,
+    buyVolumes: { ...bars[0]!.buyVolumes },
+    sellVolumes: { ...bars[0]!.sellVolumes },
   };
 
   for (let i = 1; i < bars.length; ++i) {
-    const nextBar = bars[i];
+    const nextBar = bars[i]!;
 
     bar.openInterest = nextBar.openInterest;
     bar.closePrice = nextBar.closePrice;
@@ -73,14 +73,9 @@ export const mergeBarData = (bars: BarData[]): BarData => {
     bar.amount += nextBar.amount;
 
     for (const price in nextBar.buyVolumes) {
-      const volumeDelta = nextBar.buyVolumes[price];
-
-      if (price in bar.buyVolumes) {
-        bar.buyVolumes[price] += volumeDelta;
-      } else {
-        bar.buyVolumes[price] = volumeDelta;
-      }
+      const volumeDelta = nextBar.buyVolumes[price]!;
 
+      bar.buyVolumes[price] = volumeDelta + (bar.buyVolumes[price] ?? 0);
       bar.delta += volumeDelta;
 
       const priceVP = bar.buyVolumes[price] + (bar.sellVolumes[price] ?? 0);
@@ -92,14 +87,9 @@ export const mergeBarData = (bars: BarData[]): BarData => {
     }
 
     for (const price in nextBar.sellVolumes) {
-      const volumeDelta = nextBar.sellVolumes[price];
-
-      if (price in bar.sellVolumes) {
-        bar.sellVolumes[price] += volumeDelta;
-      } else {
-        bar.sellVolumes[price] = volumeDelta;
-      }
+      const volumeDelta = nextBar.sellVolumes[price]!;
 
+      bar.sellVolumes[price] = volumeDelta + (bar.sellVolumes[price] ?? 0);
       bar.delta -= volumeDelta;
 
       const priceVP = bar.sellVolumes[price] + (bar.buyVolumes[price] ?? 0);