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

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

@@ -0,0 +1,86 @@
+/**
+ * @dev PnL calculation module
+ * @dev Provides functions matching v10 contract implementations
+ */
+import { Trade, TradeInfo, LiquidationParams } from "../types";
+import { ComprehensivePnlResult } from "./types";
+import { GetBorrowingFeeContext, BorrowingFee } from "../fees";
+import { GetTradeFeesContext } from "../fees/trading";
+import { ContractsVersion } from "../../contracts/types";
+/**
+ * @dev Calculates PnL percentage for a position
+ * @dev Mirrors contract's getPnlPercent function
+ * @param openPrice Trade open price
+ * @param currentPrice Current market price
+ * @param long Whether position is long
+ * @param leverage Position leverage
+ * @returns PnL percentage (e.g., 10 = 10% profit, -50 = 50% loss)
+ */
+export declare const getPnlPercent: (openPrice: number, currentPrice: number, long: boolean, leverage: number) => number;
+/**
+ * @dev Calculates trade value from collateral and PnL
+ * @dev Mirrors contract's getTradeValuePure function
+ * @param collateral Trade collateral amount
+ * @param pnlPercent PnL percentage
+ * @param totalFees Total fees to deduct
+ * @returns Trade value after PnL and fees
+ */
+export declare const getTradeValue: (collateral: number, pnlPercent: number, totalFees: number) => number;
+/**
+ * @dev Context for comprehensive PnL calculations
+ */
+export type GetComprehensivePnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
+    collateralPriceUsd: number;
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    initialAccFees?: BorrowingFee.InitialAccFees;
+    borrowingProviderContext?: any;
+    fundingParams?: any;
+    fundingData?: any;
+    pairOiAfterV10?: any;
+    netExposureToken?: any;
+    netExposureUsd?: any;
+    tradeFeesData?: {
+        initialAccFundingFeeP: number;
+        initialAccBorrowingFeeP: number;
+        realizedPnlCollateral: number;
+        realizedTradingFeesCollateral: number;
+        manuallyRealizedNegativePnlCollateral?: number;
+        alreadyTransferredNegativePnlCollateral?: number;
+        virtualAvailableCollateralInDiamond?: number;
+    };
+    liquidationParams?: LiquidationParams;
+};
+/**
+ * @dev Comprehensive PnL calculation including all fees
+ * @param trade The trade to calculate PnL for
+ * @param currentPrice Current market price
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @returns Detailed PnL breakdown
+ */
+export declare const getComprehensivePnl: (trade: Trade, currentPrice: number, tradeInfo: TradeInfo, context: GetComprehensivePnlContext) => ComprehensivePnlResult;
+/**
+ * @dev Legacy getPnl function for backward compatibility
+ * @deprecated Use getComprehensivePnl for new implementations
+ */
+export type GetPnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
+    collateralPriceUsd: number | undefined;
+    contractsVersion: ContractsVersion | undefined;
+    feeMultiplier: number | undefined;
+};
+/**
+ * @dev Legacy PnL calculation function
+ * @deprecated Use getComprehensivePnl for more comprehensive calculations
+ * @param price Current price
+ * @param trade Trade object
+ * @param tradeInfo Trade info (not used in legacy implementation)
+ * @param initialAccFees Initial accumulated fees
+ * @param liquidationParams Liquidation parameters
+ * @param useFees Whether to include fees
+ * @param context Context with fee calculation parameters
+ * @returns [pnlCollateral, pnlPercentage] or undefined if no price
+ */
+export declare const getPnl: (price: number | undefined, trade: Trade, _tradeInfo: TradeInfo, initialAccFees: BorrowingFee.InitialAccFees, liquidationParams: LiquidationParams, useFees: boolean, context: GetPnlContext) => number[] | undefined;
+export * from "./types";
+export * from "./converter";

package/lib/trade/pnl/index.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * @dev PnL calculation module
+ * @dev Provides functions matching v10 contract implementations
+ */
+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.getPnl = exports.getComprehensivePnl = exports.getTradeValue = exports.getPnlPercent = void 0;
+const fees_1 = require("../fees");
+const borrowingV2_1 = require("../fees/borrowingV2");
+const fundingFees_1 = require("../fees/fundingFees");
+const trading_1 = require("../fees/trading");
+const liquidation_1 = require("../liquidation");
+const types_1 = require("../../contracts/types");
+/**
+ * @dev Calculates PnL percentage for a position
+ * @dev Mirrors contract's getPnlPercent function
+ * @param openPrice Trade open price
+ * @param currentPrice Current market price
+ * @param long Whether position is long
+ * @param leverage Position leverage
+ * @returns PnL percentage (e.g., 10 = 10% profit, -50 = 50% loss)
+ */
+const getPnlPercent = (openPrice, currentPrice, long, leverage) => {
+    if (openPrice === 0)
+        return -100;
+    const priceDiff = long ? currentPrice - openPrice : openPrice - currentPrice;
+    const pnlPercent = (priceDiff / openPrice) * 100 * leverage;
+    // Cap at -100% loss
+    return Math.max(pnlPercent, -100);
+};
+exports.getPnlPercent = getPnlPercent;
+/**
+ * @dev Calculates trade value from collateral and PnL
+ * @dev Mirrors contract's getTradeValuePure function
+ * @param collateral Trade collateral amount
+ * @param pnlPercent PnL percentage
+ * @param totalFees Total fees to deduct
+ * @returns Trade value after PnL and fees
+ */
+const getTradeValue = (collateral, pnlPercent, totalFees) => {
+    const pnlCollateral = collateral * (pnlPercent / 100);
+    const value = collateral + pnlCollateral - totalFees;
+    return Math.max(0, value);
+};
+exports.getTradeValue = getTradeValue;
+/**
+ * @dev Comprehensive PnL calculation including all fees
+ * @param trade The trade to calculate PnL for
+ * @param currentPrice Current market price
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @returns Detailed PnL breakdown
+ */
+const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
+    // Calculate base PnL percentage
+    let pnlPercent = (0, exports.getPnlPercent)(trade.openPrice, currentPrice, trade.long, trade.leverage);
+    // Calculate position size
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Initialize fees
+    let borrowingFeeV1 = 0;
+    let borrowingFeeV2 = 0;
+    let fundingFee = 0;
+    // Calculate holding fees based on version
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.tradeFeesData) {
+        // V10: Use aggregated holding fees function
+        const holdingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, // Cast to handle partial type
+        currentPrice, context);
+        fundingFee = holdingFees.fundingFeeCollateral;
+        borrowingFeeV2 = holdingFees.borrowingFeeCollateral;
+        borrowingFeeV1 = holdingFees.borrowingFeeCollateral_old;
+    }
+    else {
+        // Pre-v10: Calculate fees individually
+        // V1 borrowing fees (still used by some markets)
+        if (context.initialAccFees) {
+            borrowingFeeV1 = (0, fees_1.getBorrowingFee)(positionSizeCollateral, trade.pairIndex, trade.long, context.initialAccFees, context);
+        }
+        // V2 borrowing fees
+        if (context.tradeFeesData && context.borrowingProviderContext) {
+            borrowingFeeV2 = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+                positionSizeCollateral,
+                openPrice: trade.openPrice,
+                collateralIndex: trade.collateralIndex,
+                pairIndex: trade.pairIndex,
+                currentPairPrice: currentPrice,
+                initialAccBorrowingFeeP: context.tradeFeesData.initialAccBorrowingFeeP,
+                currentTimestamp: context.currentTimestamp,
+            }, context.borrowingProviderContext);
+        }
+        // Funding fees (v10+)
+        if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+            context.tradeFeesData) {
+            fundingFee = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, // Cast to handle partial type
+            currentPrice, context);
+        }
+    }
+    // Calculate closing fees
+    const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(trade.collateralIndex, trade.user, trade.pairIndex, positionSizeCollateral, trade.isCounterTrade || false, context);
+    // Total fees
+    const totalFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee + closingFee;
+    // Check liquidation
+    const liquidationThreshold = context.liquidationParams
+        ? (0, liquidation_1.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage) * -100
+        : -90; // Default 90% loss
+    const isLiquidated = pnlPercent <= liquidationThreshold;
+    // If liquidated, set PnL to -100%
+    if (isLiquidated) {
+        pnlPercent = -100;
+    }
+    // Calculate final trade value
+    const tradeValue = (0, exports.getTradeValue)(trade.collateralAmount, pnlPercent, totalFees);
+    // Calculate PnL in collateral
+    const pnlCollateral = trade.collateralAmount * (pnlPercent / 100);
+    // Calculate leveraged position size
+    const leveragedPositionSize = trade.collateralAmount * trade.leverage;
+    // Calculate net PnL after fees
+    const netPnlAfterFees = pnlCollateral - totalFees;
+    return {
+        // Core PnL values
+        pnlPercent,
+        pnlCollateral,
+        tradeValue,
+        // Fee breakdown
+        fees: {
+            borrowingV1: borrowingFeeV1,
+            borrowingV2: borrowingFeeV2,
+            funding: fundingFee,
+            closing: closingFee,
+            total: totalFees,
+        },
+        // Status flags
+        isLiquidated,
+        isProfitable: pnlPercent > 0,
+        // Additional info
+        leveragedPositionSize,
+        netPnlAfterFees,
+    };
+};
+exports.getComprehensivePnl = getComprehensivePnl;
+/**
+ * @dev Legacy PnL calculation function
+ * @deprecated Use getComprehensivePnl for more comprehensive calculations
+ * @param price Current price
+ * @param trade Trade object
+ * @param tradeInfo Trade info (not used in legacy implementation)
+ * @param initialAccFees Initial accumulated fees
+ * @param liquidationParams Liquidation parameters
+ * @param useFees Whether to include fees
+ * @param context Context with fee calculation parameters
+ * @returns [pnlCollateral, pnlPercentage] or undefined if no price
+ */
+const getPnl = (price, trade, _tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
+    var _a;
+    if (!price) {
+        return;
+    }
+    const posCollat = trade.collateralAmount;
+    const { openPrice, leverage } = trade;
+    let pnlCollat = trade.long
+        ? ((price - openPrice) / openPrice) * leverage * posCollat
+        : ((openPrice - price) / openPrice) * leverage * posCollat;
+    if (useFees) {
+        pnlCollat -= (0, fees_1.getBorrowingFee)(posCollat * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
+    }
+    let pnlPercentage = (pnlCollat / posCollat) * 100;
+    // Can be liquidated
+    if (pnlPercentage <=
+        (0, liquidation_1.getLiqPnlThresholdP)(liquidationParams, leverage) * -100) {
+        pnlPercentage = -100;
+    }
+    else {
+        // 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;
+    pnlCollat = (posCollat * pnlPercentage) / 100;
+    return [pnlCollat, pnlPercentage];
+};
+exports.getPnl = getPnl;
+// Re-export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./converter"), exports);

package/lib/trade/pnl/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @dev Types for PnL calculations
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../types";
+/**
+ * @dev Input for trade value calculation with all fees
+ * @dev Mirrors contract's TradeValueInput struct
+ */
+export type TradeValueInput = {
+    trade: Trade;
+    currentPrice: number;
+    collateralPriceUsd: number;
+    fees: {
+        openingFeeCollateral: number;
+        closingFeeCollateral: number;
+        holdingFeesCollateral: number;
+    };
+};
+/**
+ * @dev Result of trade value calculation
+ */
+export type TradeValueResult = {
+    tradeValue: number;
+    pnlPercent: number;
+    pnlCollateral: number;
+    totalFees: number;
+};
+/**
+ * @dev Detailed fee breakdown
+ */
+export type FeeBreakdown = {
+    borrowingV1: number;
+    borrowingV2: number;
+    funding: number;
+    closing: number;
+    opening?: number;
+    total: number;
+};
+/**
+ * @dev Price impact breakdown for v10
+ */
+export type PriceImpactBreakdown = {
+    fixedSpread: number;
+    skewImpact: number;
+    cumulVolImpact: number;
+    total: number;
+    priceAfterImpact: number;
+};
+/**
+ * @dev Comprehensive PnL result with all details
+ */
+export type ComprehensivePnlResult = {
+    pnlPercent: number;
+    pnlCollateral: number;
+    tradeValue: number;
+    fees: FeeBreakdown;
+    priceImpact?: PriceImpactBreakdown;
+    isLiquidated: boolean;
+    isProfitable: boolean;
+    leveragedPositionSize: number;
+    netPnlAfterFees: number;
+};
+/**
+ * @dev Simple PnL result for backward compatibility
+ */
+export type SimplePnlResult = [pnlCollateral: number, pnlPercent: number];
+/**
+ * @dev Input for PnL calculation with price impact
+ */
+export type PnlWithPriceImpactInput = {
+    trade: Trade;
+    tradeInfo: TradeInfo;
+    oraclePrice: number;
+    currentPairPrice: number;
+    usePriceImpact: boolean;
+    includeOpeningFees?: boolean;
+};
+/**
+ * @dev Context for v10 PnL calculations
+ */
+export type V10PnlContext = {
+    tradeFeesData: TradeFeesData;
+    priceImpactContext?: any;
+    skewContext?: any;
+    cumulVolContext?: any;
+};

package/lib/trade/pnl/types.js

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

package/lib/trade/pnl.d.ts

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

package/lib/trade/pnl.js

@@ -2,15 +2,14 @@
 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;
@@ -24,11 +23,7 @@ const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useF
         pnlPercentage = -100;
     }
     else {
-        // 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;
+        pnlCollat -= (0, fees_1.getClosingFee)(posCollat, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd, context.feeMultiplier);
         pnlPercentage = (pnlCollat / posCollat) * 100;
     }
     pnlPercentage = pnlPercentage < -100 ? -100 : pnlPercentage;

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

@@ -0,0 +1,21 @@
+/**
+ * @dev Trade closing price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeClosingPriceImpact
+ */
+import { TradeClosingPriceImpactInput, TradeClosingPriceImpactContext, TradeClosingPriceImpactResult } from "./types";
+export type { TradeClosingPriceImpactInput, TradeClosingPriceImpactContext, TradeClosingPriceImpactResult, };
+/**
+ * @dev Calculates all price impacts for trade closing
+ * @dev Mirrors contract's getTradeClosingPriceImpact function
+ * @param input Trade parameters
+ * @param context Combined context for calculations
+ * @returns Price impact breakdown and trade value
+ */
+export declare const getTradeClosingPriceImpact: (input: TradeClosingPriceImpactInput, context: TradeClosingPriceImpactContext) => TradeClosingPriceImpactResult;
+/**
+ * @dev Simplified version using oracle price as current price
+ * @param input Trade parameters (without currentPairPrice)
+ * @param context Combined context
+ * @returns Price impact breakdown and trade value
+ */
+export declare const getTradeClosingPriceImpactAtOracle: (input: Omit<TradeClosingPriceImpactInput, "currentPairPrice">, context: TradeClosingPriceImpactContext) => TradeClosingPriceImpactResult;

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

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * @dev Trade closing price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeClosingPriceImpact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeClosingPriceImpactAtOracle = exports.getTradeClosingPriceImpact = void 0;
+const cumulVol_1 = require("../cumulVol");
+const skew_1 = require("../skew");
+const types_1 = require("../../../contracts/types");
+/**
+ * @dev Calculates position size in tokens for partial close
+ * @param originalPositionSizeToken Original position size in tokens
+ * @param originalCollateral Original collateral amount
+ * @param closingCollateral Collateral amount being closed
+ * @returns Proportional position size in tokens
+ */
+const calculateClosingPositionSizeToken = (originalPositionSizeToken, originalCollateral, closingCollateral) => {
+    if (originalCollateral === 0)
+        return 0;
+    // Proportional calculation: (closingCollateral / originalCollateral) * originalPositionSizeToken
+    return (closingCollateral * originalPositionSizeToken) / originalCollateral;
+};
+/**
+ * @dev Calculates all price impacts for trade closing
+ * @dev Mirrors contract's getTradeClosingPriceImpact function
+ * @param input Trade parameters
+ * @param context Combined context for calculations
+ * @returns Price impact breakdown and trade value
+ */
+const getTradeClosingPriceImpact = (input, context) => {
+    // For trades before V9.2, return oracle price without any impact
+    if (input.contractsVersion === types_1.ContractsVersion.BEFORE_V9_2) {
+        return {
+            positionSizeToken: 0,
+            fixedSpreadP: 0,
+            cumulVolPriceImpactP: 0,
+            skewPriceImpactP: 0,
+            totalPriceImpactP: 0,
+            priceAfterImpact: input.oraclePrice,
+            tradeValueCollateralNoFactor: 0,
+        };
+    }
+    // Calculate position size in tokens (proportional to collateral being closed)
+    const positionSizeToken = input.trade.positionSizeToken
+        ? calculateClosingPositionSizeToken(input.trade.positionSizeToken, input.trade.collateralAmount, input.positionSizeCollateral)
+        : 0;
+    // Calculate fixed spread (reversed for closing)
+    const fixedSpreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.trade.long, false // closing
+    );
+    let cumulVolPriceImpactP = 0;
+    let tradeValueCollateralNoFactor = 0;
+    if (input.useCumulativeVolPriceImpact) {
+        // First pass: Calculate with negative PnL assumption
+        const positionSizeUsd = input.positionSizeCollateral * context.collateralPriceUsd;
+        cumulVolPriceImpactP = (0, cumulVol_1.getTradeCumulVolPriceImpactP)(input.trade.user, input.pairIndex, input.trade.long, positionSizeUsd, false, // Assume negative PnL initially
+        false, // closing
+        context.tradeInfo.lastPosIncreaseBlock || context.tradeInfo.createdBlock, Object.assign(Object.assign({}, context), { isOpen: false, isPnlPositive: false, contractsVersion: input.contractsVersion, createdBlock: context.tradeInfo.createdBlock }));
+        // Calculate price with conservative impact
+        const priceWithImpact = input.trade.long
+            ? input.currentPairPrice *
+                (1 - (fixedSpreadP + cumulVolPriceImpactP) / 100)
+            : input.currentPairPrice /
+                (1 - (fixedSpreadP + cumulVolPriceImpactP) / 100);
+        // Calculate trade value in collateral
+        // For long: value = positionSizeToken * priceWithImpact
+        // For short: value = positionSizeToken / priceWithImpact * openPrice^2 / currentPrice
+        if (positionSizeToken > 0) {
+            if (input.trade.long) {
+                tradeValueCollateralNoFactor = positionSizeToken * priceWithImpact;
+            }
+            else {
+                // Short calculation: profit from price decrease
+                const pnlFactor = (2 * input.trade.openPrice - priceWithImpact) / input.trade.openPrice;
+                tradeValueCollateralNoFactor = input.positionSizeCollateral * pnlFactor;
+            }
+        }
+        else {
+            tradeValueCollateralNoFactor = input.positionSizeCollateral;
+        }
+        // Determine actual PnL
+        const isPnlPositive = tradeValueCollateralNoFactor > input.trade.collateralAmount;
+        // Second pass: Recalculate with actual PnL if positive
+        if (isPnlPositive) {
+            cumulVolPriceImpactP = (0, cumulVol_1.getTradeCumulVolPriceImpactP)(input.trade.user, input.pairIndex, input.trade.long, positionSizeUsd, true, // Positive PnL
+            false, // closing
+            context.tradeInfo.lastPosIncreaseBlock ||
+                context.tradeInfo.createdBlock, Object.assign(Object.assign({}, context), { isOpen: false, isPnlPositive: true, contractsVersion: input.contractsVersion, createdBlock: context.tradeInfo.createdBlock }));
+        }
+    }
+    // Calculate skew price impact (v10+ only)
+    const skewPriceImpactP = input.contractsVersion === types_1.ContractsVersion.V10
+        ? (0, skew_1.getTradeSkewPriceImpactWithChecks)({
+            collateralIndex: input.collateralIndex,
+            pairIndex: input.pairIndex,
+            long: input.trade.long,
+            open: false,
+            positionSizeCollateral: input.positionSizeCollateral,
+            currentPrice: input.currentPairPrice,
+            contractsVersion: input.contractsVersion,
+            isCounterTrade: input.trade.isCounterTrade,
+        }, context.skewContext)
+        : 0;
+    // Total price impact (all components)
+    const totalPriceImpactP = fixedSpreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    // Calculate final price after all impacts
+    // For closing: longs get worse price when impact is positive, shorts get better
+    const priceAfterImpact = input.trade.long
+        ? input.currentPairPrice * (1 - totalPriceImpactP / 100)
+        : input.currentPairPrice / (1 - totalPriceImpactP / 100);
+    return {
+        positionSizeToken,
+        fixedSpreadP,
+        cumulVolPriceImpactP,
+        skewPriceImpactP,
+        totalPriceImpactP,
+        priceAfterImpact,
+        tradeValueCollateralNoFactor,
+    };
+};
+exports.getTradeClosingPriceImpact = getTradeClosingPriceImpact;
+/**
+ * @dev Simplified version using oracle price as current price
+ * @param input Trade parameters (without currentPairPrice)
+ * @param context Combined context
+ * @returns Price impact breakdown and trade value
+ */
+const getTradeClosingPriceImpactAtOracle = (input, context) => {
+    return (0, exports.getTradeClosingPriceImpact)(Object.assign(Object.assign({}, input), { currentPairPrice: input.oraclePrice }), context);
+};
+exports.getTradeClosingPriceImpactAtOracle = getTradeClosingPriceImpactAtOracle;

package/lib/trade/priceImpact/close/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @dev Types for trade closing price impact calculations
+ */
+import { CumulVolContext } from "../cumulVol";
+import { SkewPriceImpactContext } from "../skew/types";
+import { Trade, TradeInfo, PairIndex } from "../../types";
+/**
+ * @dev Input parameters for trade closing price impact
+ * @dev Mirrors contract's TradePriceImpactInput struct
+ */
+export type TradeClosingPriceImpactInput = {
+    trade: Trade;
+    oraclePrice: number;
+    positionSizeCollateral: number;
+    currentPairPrice: number;
+    useCumulativeVolPriceImpact: boolean;
+    collateralIndex: number;
+    pairIndex: PairIndex;
+    pairSpreadP: number;
+    contractsVersion: number;
+};
+/**
+ * @dev Context for trade closing price impact calculation
+ * Combines contexts from spread, cumul vol, and skew
+ */
+export type TradeClosingPriceImpactContext = CumulVolContext & {
+    skewContext: SkewPriceImpactContext;
+    collateralPriceUsd: number;
+    tradeInfo: TradeInfo;
+};
+/**
+ * @dev Result of trade closing price impact calculation
+ * @dev Mirrors contract's TradePriceImpact struct with additional return value
+ */
+export type TradeClosingPriceImpactResult = {
+    positionSizeToken: number;
+    fixedSpreadP: number;
+    cumulVolPriceImpactP: number;
+    skewPriceImpactP: number;
+    totalPriceImpactP: number;
+    priceAfterImpact: number;
+    tradeValueCollateralNoFactor: number;
+};

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Types for trade closing price impact calculations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,31 @@
+/**
+ * @dev Converters for cumulative volume 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 { OiWindowsSettings, OiWindow, OiWindows } from "../../types";
+/**
+ * @dev Converts contract OI windows settings to SDK format
+ * @param contractData Contract OiWindowsSettings struct
+ * @returns Normalized OI windows settings
+ */
+export declare const convertOiWindowsSettings: (contractData: IPriceImpact.OiWindowsSettingsStructOutput) => OiWindowsSettings;
+/**
+ * @dev Converts contract PairOi data to SDK OiWindow format
+ * @param contractData Contract PairOi struct with USD values
+ * @returns Normalized OI window data
+ */
+export declare const convertOiWindow: (contractData: IPriceImpact.PairOiStructOutput) => OiWindow;
+/**
+ * @dev Converts array of OI windows from contract format
+ * @param windowIds Array of window IDs (as strings for mapping)
+ * @param contractWindows Array of PairOi data from contract
+ * @returns Normalized OI windows mapping
+ */
+export declare const convertOiWindows: (windowIds: string[], contractWindows: IPriceImpact.PairOiStructOutput[]) => OiWindows;
+/**
+ * @dev Batch converter for multiple OI windows settings
+ * @param contractDataArray Array of contract OiWindowsSettings
+ * @returns Array of normalized OI windows settings
+ */
+export declare const convertOiWindowsSettingsArray: (contractDataArray: IPriceImpact.OiWindowsSettingsStructOutput[]) => OiWindowsSettings[];