@gainsnetwork/sdk 0.0.0-v10.rc1 → 0.0.0-v10.rc2

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @dev Converters for trading fee data between contract and SDK formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGlobalTradeFeeParams = exports.convertCounterTradeFeeRateMultipliers = exports.convertCounterTradeSettings = void 0;
+/**
+ * @dev Converts contract counter trade settings to SDK format
+ * @param feeRateMultiplier Fee rate multiplier from contract (1e3 precision)
+ * @param maxLeverage Max leverage from contract (1e3 precision)
+ * @returns Normalized counter trade settings
+ */
+const convertCounterTradeSettings = (feeRateMultiplier, maxLeverage) => {
+    return {
+        feeRateMultiplier: feeRateMultiplier / 1000,
+        maxLeverage: maxLeverage / 1000, // 1e3 → float
+    };
+};
+exports.convertCounterTradeSettings = convertCounterTradeSettings;
+/**
+ * @dev Converts array of counter trade fee rate multipliers from contract
+ * @param multipliers Array of fee rate multipliers (1e3 precision)
+ * @returns Array of normalized multipliers
+ */
+const convertCounterTradeFeeRateMultipliers = (multipliers) => {
+    return multipliers.map(m => m / 1000);
+};
+exports.convertCounterTradeFeeRateMultipliers = convertCounterTradeFeeRateMultipliers;
+/**
+ * @dev Converts global trade fee params from contract to SDK format
+ * @param contractParams Global trade fee params from contract
+ * @returns Normalized global trade fee params
+ */
+const convertGlobalTradeFeeParams = (contractParams) => {
+    return {
+        referralFeeP: contractParams.referralFeeP / 1e10 / 100,
+        govFeeP: contractParams.govFeeP / 1e10 / 100,
+        triggerOrderFeeP: contractParams.triggerOrderFeeP / 1e10 / 100,
+        gnsOtcFeeP: contractParams.gnsOtcFeeP / 1e10 / 100,
+        gTokenFeeP: contractParams.gTokenFeeP / 1e10 / 100,
+    };
+};
+exports.convertGlobalTradeFeeParams = convertGlobalTradeFeeParams;

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

@@ -0,0 +1,34 @@
+/**
+ * @dev Trading fee calculations for opening and closing positions
+ */
+import { Fee, PairIndex } from "../../types";
+import { GetTradeFeesContext, GetLiquidationFeesContext, GetClosingFeeContext, TradeFeesBreakdown } from "./types";
+/**
+ * @dev Returns the total fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeFeesCollateral function
+ * @param collateralIndex Collateral index (not used in calculation, for consistency)
+ * @param trader Trader address (for fee tier lookup)
+ * @param pairIndex Index of the trading pair
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param isCounterTrade Whether the trade is a counter trade
+ * @param context Context containing fee parameters and settings
+ * @returns Total fee in collateral tokens
+ */
+export declare const getTotalTradeFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, positionSizeCollateral: number, isCounterTrade: boolean, context: GetTradeFeesContext) => number;
+/**
+ * @dev Returns the fee breakdown for a trade
+ * @dev Mirrors the contract's getTradeFeesCollateral function
+ */
+export declare const getTradeFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, positionSizeCollateral: number, isCounterTrade: boolean, context: GetTradeFeesContext) => TradeFeesBreakdown;
+/**
+ * @dev Returns total liquidation fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeLiqFeesCollateral function
+ */
+export declare const getTotalTradeLiqFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, collateralAmount: number, context: GetLiquidationFeesContext) => number;
+/**
+ * @dev Legacy function for backward compatibility
+ * @deprecated Use getTotalTradeFeesCollateral instead
+ */
+export declare const getClosingFee: (collateralAmount: number, leverage: number, pairIndex: PairIndex, pairFee: Fee | undefined, _collateralPriceUsd?: number | undefined, isCounterTrade?: boolean, trader?: string, context?: GetClosingFeeContext) => number;
+export * from "./types";
+export * from "./converter";

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

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * @dev Trading fee calculations for opening and closing positions
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClosingFee = exports.getTotalTradeLiqFeesCollateral = exports.getTradeFeesCollateral = exports.getTotalTradeFeesCollateral = void 0;
+const tiers_1 = require("../tiers");
+/**
+ * @dev Returns the total fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeFeesCollateral function
+ * @param collateralIndex Collateral index (not used in calculation, for consistency)
+ * @param trader Trader address (for fee tier lookup)
+ * @param pairIndex Index of the trading pair
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param isCounterTrade Whether the trade is a counter trade
+ * @param context Context containing fee parameters and settings
+ * @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])
+        ? context.counterTradeSettings[pairIndex].feeRateMultiplier
+        : 1;
+    // Apply counter trade multiplier to position size
+    const adjustedPositionSizeCollateral = positionSizeCollateral * counterTradeFeeRateMultiplier;
+    // Calculate minimum position size in collateral
+    const minPositionSizeCollateral = minPositionSizeUsd / collateralPriceUsd;
+    // Use max of adjusted position size and minimum position size
+    const positionSizeBasis = Math.max(adjustedPositionSizeCollateral, minPositionSizeCollateral);
+    // Calculate raw fee
+    const rawFee = totalPositionSizeFeeP * positionSizeBasis;
+    // Apply trader fee tier if available
+    return (0, tiers_1.calculateFeeAmount)(trader, rawFee, context.traderFeeMultiplier);
+};
+exports.getTotalTradeFeesCollateral = getTotalTradeFeesCollateral;
+/**
+ * @dev Returns the fee breakdown for a trade
+ * @dev Mirrors the contract's getTradeFeesCollateral function
+ */
+const getTradeFeesCollateral = (collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context) => {
+    const totalFees = (0, exports.getTotalTradeFeesCollateral)(collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context);
+    const { globalTradeFeeParams } = context;
+    const totalP = globalTradeFeeParams.referralFeeP +
+        globalTradeFeeParams.govFeeP +
+        globalTradeFeeParams.triggerOrderFeeP +
+        globalTradeFeeParams.gnsOtcFeeP +
+        globalTradeFeeParams.gTokenFeeP;
+    // Distribute fees proportionally
+    return {
+        referralFeeCollateral: (totalFees * globalTradeFeeParams.referralFeeP) / totalP,
+        govFeeCollateral: (totalFees * globalTradeFeeParams.govFeeP) / totalP,
+        triggerFeeCollateral: (totalFees * globalTradeFeeParams.triggerOrderFeeP) / totalP,
+        gnsOtcFeeCollateral: (totalFees * globalTradeFeeParams.gnsOtcFeeP) / totalP,
+        gTokenFeeCollateral: (totalFees * globalTradeFeeParams.gTokenFeeP) / totalP,
+    };
+};
+exports.getTradeFeesCollateral = getTradeFeesCollateral;
+/**
+ * @dev Returns total liquidation fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeLiqFeesCollateral function
+ */
+const getTotalTradeLiqFeesCollateral = (collateralIndex, trader, pairIndex, collateralAmount, context) => {
+    const { totalLiqCollateralFeeP } = context;
+    // Calculate raw liquidation fee
+    const rawFee = collateralAmount * totalLiqCollateralFeeP;
+    // Apply trader fee tier if available
+    return (0, tiers_1.calculateFeeAmount)(trader, rawFee, context.traderFeeMultiplier);
+};
+exports.getTotalTradeLiqFeesCollateral = getTotalTradeLiqFeesCollateral;
+/**
+ * @dev Legacy function for backward compatibility
+ * @deprecated Use getTotalTradeFeesCollateral instead
+ */
+const getClosingFee = (collateralAmount, leverage, pairIndex, pairFee, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_collateralPriceUsd = 0, // Kept for backward compatibility
+isCounterTrade = false, trader, context) => {
+    if (!pairFee || !context)
+        return 0;
+    const positionSizeCollateral = collateralAmount * leverage;
+    return (0, exports.getTotalTradeFeesCollateral)(0, // collateralIndex not used
+    trader || "", pairIndex, positionSizeCollateral, isCounterTrade, context);
+};
+exports.getClosingFee = getClosingFee;
+// Export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./converter"), exports);

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

@@ -0,0 +1,39 @@
+/**
+ * @dev Types for trading fee calculations (open/close position fees)
+ */
+import { Fee, CounterTradeSettings, GlobalTradeFeeParams } from "../../types";
+/**
+ * @dev Breakdown of trading fees into components
+ */
+export type TradeFeesBreakdown = {
+    referralFeeCollateral: number;
+    govFeeCollateral: number;
+    triggerFeeCollateral: number;
+    gnsOtcFeeCollateral: number;
+    gTokenFeeCollateral: number;
+};
+/**
+ * @dev Context for calculating trading fees
+ */
+export type GetTradeFeesContext = {
+    fee: Fee;
+    collateralPriceUsd: number;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    counterTradeSettings?: {
+        [pairIndex: number]: CounterTradeSettings;
+    };
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Context for calculating liquidation fees
+ */
+export type GetLiquidationFeesContext = {
+    totalLiqCollateralFeeP: number;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Legacy support
+ */
+export type GetClosingFeeContext = GetTradeFeesContext;
+export type { GlobalTradeFeeParams };

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Types for trading fee calculations (open/close position fees)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/trade/index.d.ts

@@ -2,6 +2,7 @@ export * from "./fees";
 export * from "./pnl";
 export * from "./spread";
 export * from "./liquidation";
-export * from "./fees";
 export * from "./types";
 export * from "./oiWindows";
+export * from "./priceImpact";
+export * from "./utils";

package/lib/trade/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./fees"), exports);
 __exportStar(require("./pnl"), exports);
 __exportStar(require("./spread"), exports);
 __exportStar(require("./liquidation"), exports);
-__exportStar(require("./fees"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./oiWindows"), exports);
+__exportStar(require("./priceImpact"), exports);
+__exportStar(require("./utils"), exports);

package/lib/trade/liquidation.d.ts

@@ -1,12 +1,42 @@
 import { GetBorrowingFeeContext, BorrowingFee } from "./fees";
-import { Fee, LiquidationParams, Trade, UserPriceImpact } from "./types";
+import { GetLiquidationFeesContext } from "./fees/trading";
+import { BorrowingFeeV2 } from "./fees/borrowingV2";
+import { Fee, LiquidationParams, Trade, TradeInfo, UserPriceImpact, TradeFeesData } from "./types";
 import { ContractsVersion } from "../contracts/types";
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & {
+export type GetLiquidationPriceContext = GetBorrowingFeeContext & BorrowingFeeV2.GetBorrowingFeeV2Context & GetLiquidationFeesContext & {
     liquidationParams: LiquidationParams | undefined;
     pairSpreadP: number | undefined;
     collateralPriceUsd: number | undefined;
     contractsVersion: ContractsVersion | undefined;
     userPriceImpact?: UserPriceImpact | undefined;
+    currentPairPrice?: number;
+    isCounterTrade?: boolean;
+    tradeFeesData?: TradeFeesData;
+    partialCloseMultiplier?: number;
+    additionalFeeCollateral?: number;
+    beforeOpened?: boolean;
+    initialAccFees?: BorrowingFee.InitialAccFees;
+    fundingParams?: Record<number, Record<number, any>>;
+    fundingData?: Record<number, Record<number, any>>;
+    pairOiAfterV10?: Record<number, Record<number, any>>;
+    netExposureToken?: Record<number, Record<number, number>>;
+    netExposureUsd?: Record<number, Record<number, number>>;
 };
+export type TradeHoldingFees = {
+    fundingFeeCollateral: number;
+    borrowingFeeCollateral: number;
+    borrowingFeeCollateral_old: number;
+    totalFeeCollateral: number;
+};
+/**
+ * @dev Calculates total holding fees for a trade (funding + borrowing fees)
+ * @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 Context with fee parameters
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateral: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetLiquidationPriceContext) => TradeHoldingFees;
 export declare const getLiquidationPrice: (trade: Trade, fee: Fee, initialAccFees: BorrowingFee.InitialAccFees, context: GetLiquidationPriceContext) => number;
 export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;

package/lib/trade/liquidation.js

@@ -1,27 +1,112 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
+exports.getLiqPnlThresholdP = exports.getLiquidationPrice = exports.getTradePendingHoldingFeesCollateral = void 0;
 const fees_1 = require("./fees");
+const trading_1 = require("./fees/trading");
+const borrowingV2_1 = require("./fees/borrowingV2");
 const spread_1 = require("./spread");
 const types_1 = require("../contracts/types");
+/**
+ * @dev Calculates total holding fees for a trade (funding + borrowing fees)
+ * @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 Context with fee parameters
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    var _a;
+    // Calculate funding fees (v10+ only)
+    const fundingFeeCollateral = ((_a = context.contractsVersion) !== null && _a !== void 0 ? _a : tradeInfo.contractsVersion) >=
+        types_1.ContractsVersion.V10
+        ? (0, fees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, context)
+        : 0;
+    // Calculate borrowing fees v2
+    const borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+        positionSizeCollateral: trade.collateralAmount * trade.leverage,
+        openPrice: trade.openPrice,
+        collateralIndex: trade.collateralIndex,
+        pairIndex: trade.pairIndex,
+        currentPairPrice,
+        initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+        currentTimestamp: context.currentTimestamp,
+    }, context);
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    const borrowingFeeCollateral_old = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, context.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, // Use context initial fees or empty
+    context);
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateral = getTradePendingHoldingFeesCollateral;
 const getLiquidationPrice = (trade, fee, initialAccFees, context) => {
-    var _a, _b;
-    const closingFee = (0, fees_1.getClosingFee)(trade.collateralAmount, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd);
-    const borrowingFee = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
+    var _a, _b, _c, _d, _e, _f;
+    // Ensure initialAccFees is in context
+    if (!context.initialAccFees) {
+        context = Object.assign(Object.assign({}, context), { initialAccFees });
+    }
+    // 1. Calculate liquidation fees
+    const closingFee = (0, trading_1.getTotalTradeLiqFeesCollateral)(0, // collateralIndex not used in calculation
+    trade.user, trade.pairIndex, trade.collateralAmount, context);
+    // 2. Calculate holding fees and realized PnL
+    let holdingFeesTotal = 0;
+    let totalRealizedPnlCollateral = 0;
+    if (!context.beforeOpened &&
+        context.tradeFeesData &&
+        context.currentPairPrice) {
+        // V10 data available - calculate full holding fees
+        // Create a minimal tradeInfo from context
+        const tradeInfo = {
+            contractsVersion: (_a = context.contractsVersion) !== null && _a !== void 0 ? _a : types_1.ContractsVersion.V10,
+            createdBlock: 0,
+            tpLastUpdatedBlock: 0,
+            slLastUpdatedBlock: 0,
+            maxSlippageP: 0,
+            lastOiUpdateTs: 0,
+            collateralPriceUsd: (_b = context.collateralPriceUsd) !== null && _b !== void 0 ? _b : 0,
+            lastPosIncreaseBlock: 0,
+        };
+        const holdingFees = (0, exports.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, context.currentPairPrice, context);
+        holdingFeesTotal = holdingFees.totalFeeCollateral;
+        // Calculate total realized PnL (realized PnL minus realized trading fees)
+        totalRealizedPnlCollateral =
+            context.tradeFeesData.realizedPnlCollateral -
+                context.tradeFeesData.realizedTradingFeesCollateral;
+    }
+    else if (!context.beforeOpened) {
+        // Markets using v1 borrowing fees model
+        holdingFeesTotal = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
+    }
+    // 3. Apply unified formula for all trades
+    const partialCloseMultiplier = (_c = context.partialCloseMultiplier) !== null && _c !== void 0 ? _c : 1;
+    const additionalFeeCollateral = (_d = context.additionalFeeCollateral) !== null && _d !== void 0 ? _d : 0;
+    const totalFeesCollateral = closingFee +
+        (holdingFeesTotal - totalRealizedPnlCollateral) * partialCloseMultiplier +
+        additionalFeeCollateral;
+    // 4. Calculate liquidation threshold
     const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage);
-    let liqPriceDistance = (trade.openPrice *
-        (trade.collateralAmount * liqThresholdP - (borrowingFee + closingFee))) /
+    // 5. Calculate liquidation price distance
+    const collateralLiqNegativePnl = trade.collateralAmount * liqThresholdP;
+    let liqPriceDistance = (trade.openPrice * (collateralLiqNegativePnl - totalFeesCollateral)) /
         trade.collateralAmount /
         trade.leverage;
+    // 6. Apply closing spread for v9.2+
     if ((context === null || context === void 0 ? void 0 : context.contractsVersion) !== undefined &&
         context.contractsVersion >= types_1.ContractsVersion.V9_2 &&
-        ((((_a = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
+        ((((_e = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _e === void 0 ? void 0 : _e.maxLiqSpreadP) !== undefined &&
             context.liquidationParams.maxLiqSpreadP > 0) ||
-            (((_b = context === null || context === void 0 ? void 0 : context.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !== undefined &&
+            (((_f = context === null || context === void 0 ? void 0 : context.userPriceImpact) === null || _f === void 0 ? void 0 : _f.fixedSpreadP) !== undefined &&
                 context.userPriceImpact.fixedSpreadP > 0))) {
         const closingSpreadP = (0, spread_1.getSpreadP)(context.pairSpreadP, true, context.liquidationParams, context.userPriceImpact);
         liqPriceDistance -= trade.openPrice * closingSpreadP;
     }
+    // 7. Calculate final liquidation price
     return trade.long
         ? Math.max(trade.openPrice - liqPriceDistance, 0)
         : Math.max(trade.openPrice + liqPriceDistance, 0);

package/lib/trade/pnl.d.ts

@@ -1,8 +1,8 @@
 import { GetBorrowingFeeContext } from "./fees";
-import { Fee, LiquidationParams, Trade, TradeInfo, TradeInitialAccFees } from "./types";
+import { GetTradeFeesContext } from "./fees/trading";
+import { LiquidationParams, Trade, TradeInfo, TradeInitialAccFees } from "./types";
 import { ContractsVersion } from "../contracts/types";
-export type GetPnlContext = GetBorrowingFeeContext & {
-    fee: Fee | undefined;
+export type GetPnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
     collateralPriceUsd: number | undefined;
     contractsVersion: ContractsVersion | undefined;
     feeMultiplier: number | undefined;

package/lib/trade/pnl.js

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPnl = void 0;
 const fees_1 = require("./fees");
+const trading_1 = require("./fees/trading");
 const liquidation_1 = require("./liquidation");
 const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
+    var _a;
     if (!price) {
         return;
     }
     const posCollat = trade.collateralAmount;
     const { openPrice, leverage } = trade;
-    const { fee } = context;
     let pnlCollat = trade.long
         ? ((price - openPrice) / openPrice) * leverage * posCollat
         : ((openPrice - price) / openPrice) * leverage * posCollat;
@@ -23,7 +24,11 @@ const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useF
         pnlPercentage = -100;
     }
     else {
-        pnlCollat -= (0, fees_1.getClosingFee)(posCollat, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd, context.feeMultiplier);
+        // 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, context);
+        pnlCollat -= closingFee;
         pnlPercentage = (pnlCollat / posCollat) * 100;
     }
     pnlPercentage = pnlPercentage < -100 ? -100 : pnlPercentage;

package/lib/trade/priceImpact/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @dev Main price impact module
+ * @dev Exports skew price impact functionality (v10+)
+ * @dev Cumulative volume price impact remains in spread.ts for now
+ */
+export { getNetSkewToken, getNetSkewCollateral, getTradeSkewDirection, calculateSkewPriceImpactP, getTradeSkewPriceImpact, getTradeSkewPriceImpactWithChecks, calculatePartialSizeToken, SkewPriceImpact, } from "./skew";
+export { convertPairOiToken, convertPairOiTokenArray, convertPairOiCollateral, convertPairOiCollateralArray, normalizeSkewDepth, createSkewDepth, createSkewPriceImpactContext, isValidSkewDepth, convertSkewDepthsArray, mergeSkewPriceImpactContexts, } from "./skew/converter";
+export type { PairOiToken, PairOiCollateral, SkewDepth, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext, TradeSkewParams, PositionSizeResult, } from "./skew/types";

package/lib/trade/priceImpact/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @dev Main price impact module
+ * @dev Exports skew price impact functionality (v10+)
+ * @dev Cumulative volume price impact remains in spread.ts for now
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSkewPriceImpactContexts = exports.convertSkewDepthsArray = exports.isValidSkewDepth = exports.createSkewPriceImpactContext = exports.createSkewDepth = exports.normalizeSkewDepth = exports.convertPairOiCollateralArray = exports.convertPairOiCollateral = exports.convertPairOiTokenArray = exports.convertPairOiToken = exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpactWithChecks = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
+// Export skew price impact functionality
+var skew_1 = require("./skew");
+// Core functions
+Object.defineProperty(exports, "getNetSkewToken", { enumerable: true, get: function () { return skew_1.getNetSkewToken; } });
+Object.defineProperty(exports, "getNetSkewCollateral", { enumerable: true, get: function () { return skew_1.getNetSkewCollateral; } });
+Object.defineProperty(exports, "getTradeSkewDirection", { enumerable: true, get: function () { return skew_1.getTradeSkewDirection; } });
+Object.defineProperty(exports, "calculateSkewPriceImpactP", { enumerable: true, get: function () { return skew_1.calculateSkewPriceImpactP; } });
+Object.defineProperty(exports, "getTradeSkewPriceImpact", { enumerable: true, get: function () { return skew_1.getTradeSkewPriceImpact; } });
+Object.defineProperty(exports, "getTradeSkewPriceImpactWithChecks", { enumerable: true, get: function () { return skew_1.getTradeSkewPriceImpactWithChecks; } });
+Object.defineProperty(exports, "calculatePartialSizeToken", { enumerable: true, get: function () { return skew_1.calculatePartialSizeToken; } });
+// Types namespace
+Object.defineProperty(exports, "SkewPriceImpact", { enumerable: true, get: function () { return skew_1.SkewPriceImpact; } });
+// Export converters
+var converter_1 = require("./skew/converter");
+Object.defineProperty(exports, "convertPairOiToken", { enumerable: true, get: function () { return converter_1.convertPairOiToken; } });
+Object.defineProperty(exports, "convertPairOiTokenArray", { enumerable: true, get: function () { return converter_1.convertPairOiTokenArray; } });
+Object.defineProperty(exports, "convertPairOiCollateral", { enumerable: true, get: function () { return converter_1.convertPairOiCollateral; } });
+Object.defineProperty(exports, "convertPairOiCollateralArray", { enumerable: true, get: function () { return converter_1.convertPairOiCollateralArray; } });
+Object.defineProperty(exports, "normalizeSkewDepth", { enumerable: true, get: function () { return converter_1.normalizeSkewDepth; } });
+Object.defineProperty(exports, "createSkewDepth", { enumerable: true, get: function () { return converter_1.createSkewDepth; } });
+Object.defineProperty(exports, "createSkewPriceImpactContext", { enumerable: true, get: function () { return converter_1.createSkewPriceImpactContext; } });
+Object.defineProperty(exports, "isValidSkewDepth", { enumerable: true, get: function () { return converter_1.isValidSkewDepth; } });
+Object.defineProperty(exports, "convertSkewDepthsArray", { enumerable: true, get: function () { return converter_1.convertSkewDepthsArray; } });
+Object.defineProperty(exports, "mergeSkewPriceImpactContexts", { enumerable: true, get: function () { return converter_1.mergeSkewPriceImpactContexts; } });

package/lib/trade/priceImpact/skew/converter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @dev Converters for skew price impact data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+import { IPriceImpact } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { PairOiToken, PairOiCollateral, SkewDepth, SkewPriceImpactContext } from "./types";
+/**
+ * @dev Converts contract pair OI token data to SDK format
+ * @param contractData Contract pair OI token struct
+ * @returns Normalized pair OI token data
+ */
+export declare const convertPairOiToken: (contractData: IPriceImpact.PairOiTokenStruct) => PairOiToken;
+/**
+ * @dev Converts array of contract pair OI token data to SDK format
+ * @param contractDataArray Array of contract pair OI token data
+ * @returns Array of normalized pair OI token data
+ */
+export declare const convertPairOiTokenArray: (contractDataArray: IPriceImpact.PairOiTokenStruct[]) => PairOiToken[];
+/**
+ * @dev Converts contract pair OI collateral data to SDK format
+ * @param contractData Contract pair OI collateral struct
+ * @param collateralDecimals Number of decimals for the collateral (e.g., 18 for DAI, 6 for USDC)
+ * @returns Normalized pair OI collateral data
+ */
+export declare const convertPairOiCollateral: (contractData: IPriceImpact.PairOiCollateralStruct, collateralDecimals: number) => PairOiCollateral;
+/**
+ * @dev Converts array of contract pair OI collateral data to SDK format
+ * @param contractDataArray Array of contract pair OI collateral data
+ * @param collateralDecimals Array of collateral decimals for each entry
+ * @returns Array of normalized pair OI collateral data
+ */
+export declare const convertPairOiCollateralArray: (contractDataArray: IPriceImpact.PairOiCollateralStruct[], collateralDecimals: number[]) => PairOiCollateral[];
+/**
+ * @dev Normalizes skew depth from contract format
+ * @param depth Skew depth from contract (in collateral wei)
+ * @param collateralDecimals Number of decimals for the collateral
+ * @returns Normalized skew depth
+ */
+export declare const normalizeSkewDepth: (depth: bigint | number | string, collateralDecimals: number) => number;
+/**
+ * @dev Creates a skew depth object
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param depth Normalized depth value
+ * @returns Skew depth object
+ */
+export declare const createSkewDepth: (collateralIndex: number, pairIndex: number, depth: number) => SkewDepth;
+/**
+ * @dev Creates skew price impact context from arrays of data
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param skewDepths Array of normalized skew depths
+ * @param pairOiTokens Array of pair OI token data
+ * @returns Complete skew price impact context
+ */
+export declare const createSkewPriceImpactContext: (collateralIndices: number[], pairIndices: number[], skewDepths: number[], pairOiTokens: PairOiToken[]) => SkewPriceImpactContext;
+/**
+ * @dev Validates skew depth is within reasonable bounds
+ * @param depth Normalized skew depth
+ * @param minDepth Minimum allowed depth (default: 0)
+ * @param maxDepth Maximum allowed depth (default: 1e12)
+ * @returns Whether depth is valid
+ */
+export declare const isValidSkewDepth: (depth: number, minDepth?: number, maxDepth?: number) => boolean;
+/**
+ * @dev Converts contract skew depths array to normalized values
+ * @param contractDepths Array of depths from contract
+ * @param collateralDecimals Array of decimals for each collateral
+ * @returns Array of normalized depths
+ */
+export declare const convertSkewDepthsArray: (contractDepths: Array<bigint | number | string>, collateralDecimals: number[]) => number[];
+/**
+ * @dev Merges multiple contexts into one
+ * @param contexts Array of contexts to merge
+ * @returns Merged context
+ */
+export declare const mergeSkewPriceImpactContexts: (contexts: SkewPriceImpactContext[]) => SkewPriceImpactContext;