@gainsnetwork/sdk 1.4.0-rc1 → 1.4.2-rc1

package/lib/trade/fees/holdingFees/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+import { FundingFeeParams, PairFundingFeeData, PairOiAfterV10 } from "../fundingFees/types";
+import { BorrowingFeeParams, PairBorrowingFeeData } from "../borrowingV2/types";
+export type HoldingFeeRates = {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+};
+export type GetPairHoldingFeeRatesInput = {
+    fundingParams: FundingFeeParams;
+    fundingData: PairFundingFeeData;
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: BorrowingFeeParams | null;
+    borrowingData: PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+};
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+export declare const getPairHoldingFeeRates: (input: GetPairHoldingFeeRatesInput) => HoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+export declare const convertRatePerSecondToAPR: (ratePerSecond: number) => number;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+export declare const formatHoldingFeeRate: (rate: number, decimals?: number) => string;
+export * as HoldingFees from "./types";

package/lib/trade/fees/holdingFees/index.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoldingFees = exports.formatHoldingFeeRate = exports.convertRatePerSecondToAPR = exports.getPairHoldingFeeRates = void 0;
+const fundingFees_1 = require("../fundingFees");
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+const PERCENTAGE_PRECISION = 100;
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+const getPairHoldingFeeRates = (input) => {
+    const { fundingParams, fundingData, pairOiToken, netExposureToken, netExposureUsd, borrowingParams, borrowingData, currentPairPrice, currentTimestamp, } = input;
+    // Calculate funding fee rates
+    let fundingFeeLongHourlyRate = 0;
+    let fundingFeeShortHourlyRate = 0;
+    let currentFundingRatePerSecondP = 0;
+    if (fundingParams.fundingFeesEnabled) {
+        // Get current funding rate
+        const pendingFunding = (0, fundingFees_1.getPairPendingAccFundingFees)(fundingParams, fundingData, currentPairPrice, pairOiToken, netExposureToken, netExposureUsd, currentTimestamp);
+        currentFundingRatePerSecondP = pendingFunding.currentFundingRatePerSecondP;
+        // Get APR multipliers
+        const { longAprMultiplier, shortAprMultiplier } = (0, fundingFees_1.getLongShortAprMultiplier)(currentFundingRatePerSecondP, pairOiToken.oiLongToken, pairOiToken.oiShortToken, fundingParams.aprMultiplierEnabled);
+        // Calculate hourly rates
+        // Funding rate * seconds per hour * current price * APR multiplier / 100
+        const baseHourlyRate = (currentFundingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+            PERCENTAGE_PRECISION;
+        // Long side pays when rate is positive, earns when negative
+        fundingFeeLongHourlyRate = baseHourlyRate * longAprMultiplier;
+        // Short side is opposite
+        fundingFeeShortHourlyRate = -baseHourlyRate * shortAprMultiplier;
+    }
+    // Calculate borrowing v2 rates
+    let borrowingFeeHourlyRate = 0;
+    let currentBorrowingRatePerSecondP = 0;
+    if (borrowingParams && borrowingData) {
+        currentBorrowingRatePerSecondP = borrowingParams.borrowingRatePerSecondP;
+        // Borrowing rate * seconds per hour * current price / 100
+        borrowingFeeHourlyRate =
+            (currentBorrowingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+                PERCENTAGE_PRECISION;
+    }
+    // Total holding fees (funding can be negative/positive, borrowing always positive cost)
+    const longHourlyRate = fundingFeeLongHourlyRate + borrowingFeeHourlyRate;
+    const shortHourlyRate = fundingFeeShortHourlyRate + borrowingFeeHourlyRate;
+    return {
+        longHourlyRate,
+        shortHourlyRate,
+        fundingFeeLongHourlyRate,
+        fundingFeeShortHourlyRate,
+        borrowingFeeHourlyRate,
+        currentFundingRatePerSecondP,
+        currentBorrowingRatePerSecondP,
+    };
+};
+exports.getPairHoldingFeeRates = getPairHoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+const convertRatePerSecondToAPR = (ratePerSecond) => {
+    return ratePerSecond * SECONDS_PER_YEAR * PERCENTAGE_PRECISION;
+};
+exports.convertRatePerSecondToAPR = convertRatePerSecondToAPR;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+const formatHoldingFeeRate = (rate, decimals = 4) => {
+    const sign = rate > 0 ? "+" : "";
+    return `${sign}${rate.toFixed(decimals)}%`;
+};
+exports.formatHoldingFeeRate = formatHoldingFeeRate;
+exports.HoldingFees = __importStar(require("./types"));

package/lib/trade/fees/holdingFees/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+export interface HoldingFeeRates {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+}
+export interface GetPairHoldingFeeRatesInput {
+    fundingParams: import("../fundingFees/types").FundingFeeParams;
+    fundingData: import("../fundingFees/types").PairFundingFeeData;
+    pairOiToken: import("../fundingFees/types").PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: import("../borrowingV2/types").BorrowingFeeParams | null;
+    borrowingData: import("../borrowingV2/types").PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+}

package/lib/trade/fees/holdingFees/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/trade/fees/tiers/index.js

@@ -24,9 +24,8 @@ exports.MAX_FEE_TIERS = 8;
 const getCurrentDay = () => Math.floor(Date.now() / 1000 / 60 / 60 / 24);
 exports.getCurrentDay = getCurrentDay;
 const getFeeTiersCount = (feeTiers) => {
-    var _a;
     for (let i = exports.MAX_FEE_TIERS; i > 0; --i) {
-        if (((_a = feeTiers[i - 1]) === null || _a === void 0 ? void 0 : _a.feeMultiplier) > 0) {
+        if (feeTiers[i - 1]?.feeMultiplier > 0) {
             return i;
         }
     }

package/lib/trade/fees/trading/holdingFees.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../../types";
+import { TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+import type { BorrowingV1SubContext, BorrowingV2SubContext, FundingFeesSubContext } from "../../pnl";
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: BorrowingV1SubContext;
+    borrowingV2?: BorrowingV2SubContext;
+    funding?: FundingFeesSubContext;
+};
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateralStructured: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;

package/lib/trade/fees/trading/holdingFees.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const pairContext_1 = require("../fundingFees/pairContext");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, pairContext_1.getPairTradeFundingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            long: trade.long,
+            currentPairPrice,
+            initialAccFundingFeeP: tradeFeesData.initialAccFundingFeeP,
+        }, context.funding // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 && tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getPairTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getPairBorrowingFee)(positionSizeCollateral, trade.long, context.borrowingV1.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

package/lib/trade/fees/trading/holdingFeesStructured.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../../types";
+import { TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+import type { BorrowingV1SubContext, BorrowingV2SubContext, FundingFeesSubContext } from "../../pnl";
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: BorrowingV1SubContext;
+    borrowingV2?: BorrowingV2SubContext;
+    funding?: FundingFeesSubContext;
+};
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateralStructured: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;

package/lib/trade/fees/trading/holdingFeesStructured.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }) // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 &&
+        tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, undefined, // pairIndex not needed for pair-specific context
+        trade.long, context.borrowingV1.initialAccFees || {
+            accPairFee: 0,
+            accGroupFee: 0,
+            block: 0,
+        }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

package/lib/trade/fees/trading/index.js

@@ -35,11 +35,10 @@ const types_1 = require("../../../contracts/types");
  * @returns Total fee in collateral tokens
  */
 const getTotalTradeFeesCollateral = (collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context) => {
-    var _a;
     const { fee, collateralPriceUsd } = context;
     const { totalPositionSizeFeeP, minPositionSizeUsd } = fee;
     // Get counter trade fee rate multiplier (default 1 = 1x)
-    const counterTradeFeeRateMultiplier = isCounterTrade && ((_a = context.counterTradeSettings) === null || _a === void 0 ? void 0 : _a[pairIndex])
+    const counterTradeFeeRateMultiplier = isCounterTrade && context.counterTradeSettings?.[pairIndex]
         ? context.counterTradeSettings[pairIndex].feeRateMultiplier
         : 1;
     // Apply counter trade multiplier to position size
@@ -119,7 +118,10 @@ const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, c
     if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
         context.funding &&
         tradeFeesData.initialAccFundingFeeP !== undefined) {
-        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }));
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, {
+            ...context.funding,
+            currentTimestamp: context.currentTimestamp,
+        });
     }
     // Calculate borrowing fees v2 (v10+ only)
     let borrowingFeeCollateral = 0;

package/lib/trade/liquidation/builder.js

@@ -17,7 +17,6 @@ const builder_4 = require("../fees/trading/builder");
  * @returns Complete context ready for getLiquidationPrice
  */
 const buildLiquidationPriceContext = (globalTradingVariables, tradeContainer, additionalParams) => {
-    var _a;
     const { trade, tradeInfo } = tradeContainer;
     const collateralIndex = trade.collateralIndex || 1;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
@@ -29,7 +28,7 @@ const buildLiquidationPriceContext = (globalTradingVariables, tradeContainer, ad
         core: {
             currentBlock: additionalParams.currentBlock,
             currentTimestamp: additionalParams.currentTimestamp,
-            collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+            collateralPriceUsd: collateral.prices?.collateralPriceUsd || 1,
             contractsVersion: tradeInfo.contractsVersion,
             spreadP: additionalParams.spreadP,
         },

package/lib/trade/liquidation/index.js

@@ -27,7 +27,6 @@ const __1 = require("..");
  * @returns Liquidation price
  */
 const getLiquidationPrice = (trade, context) => {
-    var _a, _b;
     // Extract parameters from structured context
     const { currentPairPrice, additionalFeeCollateral = 0, partialCloseMultiplier = 1, beforeOpened = false, isCounterTrade = false, } = context.liquidationSpecific;
     // 1. Calculate closing fees
@@ -72,9 +71,9 @@ const getLiquidationPrice = (trade, context) => {
         trade.leverage;
     // 6. Apply closing spread for v9.2+
     if (context.core.contractsVersion >= types_1.ContractsVersion.V9_2 &&
-        ((((_a = context.tradeData.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
+        ((context.tradeData.liquidationParams?.maxLiqSpreadP !== undefined &&
             context.tradeData.liquidationParams.maxLiqSpreadP > 0) ||
-            (((_b = context.liquidationSpecific.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !==
+            (context.liquidationSpecific.userPriceImpact?.fixedSpreadP !==
                 undefined &&
                 context.liquidationSpecific.userPriceImpact.fixedSpreadP > 0))) {
         const closingSpreadP = (0, __1.getSpreadP)(context.core.spreadP, true, context.tradeData.liquidationParams, context.liquidationSpecific.userPriceImpact);
@@ -99,7 +98,6 @@ exports.getLiquidationPrice = getLiquidationPrice;
  * @returns New liquidation price after the update
  */
 const getLiquidationPriceAfterPositionUpdate = (existingTrade, newCollateralAmount, newLeverage, isLeverageUpdate, positionSizeCollateralDelta, pnlToRealizeCollateral, context) => {
-    var _a, _b;
     const { currentPairPrice, isCounterTrade = false } = context.liquidationSpecific;
     // 1. Calculate closing fees on the new position size
     const closingFeeCollateral = (0, __1.getTotalTradeFeesCollateral)(existingTrade.collateralIndex, "", // No fee tiers applied for liquidation calculation
@@ -167,9 +165,9 @@ const getLiquidationPriceAfterPositionUpdate = (existingTrade, newCollateralAmou
         newLeverage;
     // 9. Apply closing spread for v9.2+
     if (context.core.contractsVersion >= types_1.ContractsVersion.V9_2 &&
-        ((((_a = context.tradeData.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
+        ((context.tradeData.liquidationParams?.maxLiqSpreadP !== undefined &&
             context.tradeData.liquidationParams.maxLiqSpreadP > 0) ||
-            (((_b = context.liquidationSpecific.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !==
+            (context.liquidationSpecific.userPriceImpact?.fixedSpreadP !==
                 undefined &&
                 context.liquidationSpecific.userPriceImpact.fixedSpreadP > 0))) {
         const closingSpreadP = (0, __1.getSpreadP)(context.core.spreadP, true, context.tradeData.liquidationParams, context.liquidationSpecific.userPriceImpact);

package/lib/trade/oiWindows.js

@@ -7,13 +7,12 @@ const getCurrentOiWindowId = (oiWindowSettings) => {
 };
 exports.getCurrentOiWindowId = getCurrentOiWindowId;
 const getActiveOi = (currentOiWindowId, windowsCount, oiWindows, buy) => {
-    var _a, _b;
     if (oiWindows === undefined || windowsCount === 0)
         return 0;
     let activeOi = 0;
     for (let id = currentOiWindowId - (windowsCount - 1); id <= currentOiWindowId; id++) {
         activeOi +=
-            (buy ? (_a = oiWindows === null || oiWindows === void 0 ? void 0 : oiWindows[id]) === null || _a === void 0 ? void 0 : _a.oiLongUsd : (_b = oiWindows === null || oiWindows === void 0 ? void 0 : oiWindows[id]) === null || _b === void 0 ? void 0 : _b.oiShortUsd) || 0;
+            (buy ? oiWindows?.[id]?.oiLongUsd : oiWindows?.[id]?.oiShortUsd) || 0;
     }
     return activeOi;
 };

package/lib/trade/pnl/builder.js

@@ -14,7 +14,6 @@ const builder_4 = require("../fees/trading/builder");
  * @returns Complete context ready for getComprehensivePnl
  */
 const buildComprehensivePnlContext = (globalTradingVariables, tradeContainer, additionalParams) => {
-    var _a;
     const { trade, tradeInfo } = tradeContainer;
     const collateralIndex = trade.collateralIndex || 1;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
@@ -23,7 +22,7 @@ const buildComprehensivePnlContext = (globalTradingVariables, tradeContainer, ad
         core: {
             currentBlock: additionalParams.currentBlock,
             currentTimestamp: additionalParams.currentTimestamp,
-            collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+            collateralPriceUsd: collateral.prices?.collateralPriceUsd || 1,
             contractsVersion: tradeInfo.contractsVersion,
         },
         // Build sub-contexts using dedicated builders

package/lib/trade/pnl/converter.js

@@ -34,7 +34,7 @@ exports.encodePnlPercent = encodePnlPercent;
  */
 const convertCollateralAmount = (amount, collateralDecimals) => {
     const value = typeof amount === "bigint" ? Number(amount) : amount;
-    return value / Math.pow(10, collateralDecimals);
+    return value / 10 ** collateralDecimals;
 };
 exports.convertCollateralAmount = convertCollateralAmount;
 /**

package/lib/trade/pnl/index.js

@@ -81,7 +81,6 @@ exports.getTradeValue = getTradeValue;
  * @returns Detailed PnL breakdown
  */
 const getComprehensivePnl = (trade, marketPrice, executionPrice, tradeInfo, context) => {
-    var _a;
     // Calculate both raw PnL (market price) and impact-adjusted PnL (execution price)
     let rawPnlPercent = (0, exports.getPnlPercent)(trade.openPrice, marketPrice, trade.long, trade.leverage);
     let impactPnlPercent = (0, exports.getPnlPercent)(trade.openPrice, executionPrice, trade.long, trade.leverage);
@@ -115,7 +114,7 @@ const getComprehensivePnl = (trade, marketPrice, executionPrice, tradeInfo, cont
     const totalHoldingFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee;
     const totalFees = totalHoldingFees + closingFee;
     // Check liquidation (using raw PnL for liquidation check)
-    const liquidationThreshold = ((_a = context.tradeData) === null || _a === void 0 ? void 0 : _a.liquidationParams)
+    const liquidationThreshold = context.tradeData?.liquidationParams
         ? (0, liquidation_1.getLiqPnlThresholdP)(context.tradeData.liquidationParams, trade.leverage) *
             -100
         : -90; // Default 90% loss
@@ -192,7 +191,6 @@ exports.getComprehensivePnl = getComprehensivePnl;
  * @returns [pnlCollateral, pnlPercentage] or undefined if no price
  */
 const getPnl = (price, trade, _tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
-    var _a;
     if (!price) {
         return;
     }
@@ -224,7 +222,7 @@ const getPnl = (price, trade, _tradeInfo, initialAccFees, liquidationParams, use
         // Calculate closing fee using the same function as opening fees
         const positionSizeCollateral = posCollat * trade.leverage;
         const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(0, // collateralIndex not used
-        trade.user, trade.pairIndex, positionSizeCollateral, (_a = trade.isCounterTrade) !== null && _a !== void 0 ? _a : false, {
+        trade.user, trade.pairIndex, positionSizeCollateral, trade.isCounterTrade ?? false, {
             fee: context.fee,
             globalTradeFeeParams: context.globalTradeFeeParams,
             collateralPriceUsd: context.collateralPriceUsd || 1,
@@ -248,12 +246,11 @@ exports.getPnl = getPnl;
  * @returns The price that would result in the target PnL percentage
  */
 const getPriceForTargetPnlPercentage = (targetPnlPercent, trade, tradeInfo, context, netPnl = false) => {
-    var _a, _b;
     const { leverage, openPrice, long, collateralAmount } = trade;
     const positionSizeCollateral = collateralAmount * leverage;
     // Calculate holding fees - always use getTradePendingHoldingFeesCollateral
     // This mirrors the contract's getTradeValueCollateral which always calls this function
-    const fees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, ((_a = context.tradeData) === null || _a === void 0 ? void 0 : _a.tradeFeesData) || {
+    const fees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeData?.tradeFeesData || {
         realizedTradingFeesCollateral: 0,
         realizedPnlCollateral: 0,
         manuallyRealizedNegativePnlCollateral: 0,
@@ -269,7 +266,7 @@ const getPriceForTargetPnlPercentage = (targetPnlPercent, trade, tradeInfo, cont
         borrowingV1: context.borrowingV1,
         borrowingV2: context.borrowingV2,
         funding: context.funding,
-        initialAccFees: (_b = context.tradeData) === null || _b === void 0 ? void 0 : _b.initialAccFees,
+        initialAccFees: context.tradeData?.initialAccFees,
     });
     const totalHoldingFees = fees.fundingFeeCollateral +
         fees.borrowingFeeCollateral +

package/lib/trade/priceImpact/close/builder.js

@@ -14,7 +14,6 @@ const builder_2 = require("../skew/builder");
  * @returns Complete context ready for getTradeClosingPriceImpact
  */
 const buildTradeClosingPriceImpactContext = (globalTradingVariables, collateralIndex, pairIndex, tradeInfo, additionalParams) => {
-    var _a;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
     if (!collateral) {
         return undefined;
@@ -36,7 +35,7 @@ const buildTradeClosingPriceImpactContext = (globalTradingVariables, collateralI
     }
     // Return structured context with proper subcontexts
     return {
-        collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+        collateralPriceUsd: collateral.prices?.collateralPriceUsd || 1,
         cumulVolContext,
         skewContext,
         tradeInfo,

package/lib/trade/priceImpact/close/index.js

@@ -129,6 +129,9 @@ exports.getTradeClosingPriceImpact = getTradeClosingPriceImpact;
  * @returns Price impact breakdown and trade value
  */
 const getTradeClosingPriceImpactAtOracle = (input, context) => {
-    return (0, exports.getTradeClosingPriceImpact)(Object.assign(Object.assign({}, input), { currentPairPrice: input.oraclePrice }), context);
+    return (0, exports.getTradeClosingPriceImpact)({
+        ...input,
+        currentPairPrice: input.oraclePrice,
+    }, context);
 };
 exports.getTradeClosingPriceImpactAtOracle = getTradeClosingPriceImpactAtOracle;