@gainsnetwork/sdk 0.2.73-rc2 → 1.0.0-rc10

package/lib/trade/pnl/index.js

@@ -0,0 +1,303 @@
+"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.getPriceForTargetPnlPercentage = exports.getPnl = exports.getComprehensivePnl = exports.getTradeValue = exports.getPnlPercent = exports.getTradeRealizedPnlCollateral = void 0;
+const borrowing_1 = require("../fees/borrowing");
+const trading_1 = require("../fees/trading");
+const liquidation_1 = require("../liquidation");
+/**
+ * @dev Gets trade realized PnL components from TradeFeesData
+ * @dev Mirrors contract's getTradeRealizedPnlCollateral function
+ * @param tradeFeesData Trade fees data containing realized components
+ * @returns Tuple of [realizedPnlCollateral, realizedTradingFeesCollateral, totalRealizedPnlCollateral]
+ */
+const getTradeRealizedPnlCollateral = (tradeFeesData) => {
+    const realizedPnlCollateral = tradeFeesData.realizedPnlCollateral;
+    const realizedTradingFeesCollateral = tradeFeesData.realizedTradingFeesCollateral;
+    const totalRealizedPnlCollateral = realizedPnlCollateral - realizedTradingFeesCollateral;
+    return {
+        realizedPnlCollateral,
+        realizedTradingFeesCollateral,
+        totalRealizedPnlCollateral,
+    };
+};
+exports.getTradeRealizedPnlCollateral = getTradeRealizedPnlCollateral;
+/**
+ * @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 marketPrice Current market price (without price impact)
+ * @param executionPrice Price after all impacts (spread, skew, volume)
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @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);
+    if (!context.tradeData) {
+        throw new Error("Trade data is undefined");
+    }
+    // Calculate position size
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate holding fees - always use getTradePendingHoldingFeesCollateral
+    const pendingHoldingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeData.tradeFeesData, marketPrice, {
+        contractsVersion: context.core.contractsVersion,
+        currentTimestamp: context.core.currentTimestamp,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        borrowingV1: context.borrowingV1,
+        borrowingV2: context.borrowingV2,
+        funding: context.funding,
+        initialAccFees: context.tradeData.initialAccFees,
+    });
+    const borrowingFeeV1 = pendingHoldingFees.borrowingFeeCollateral_old;
+    const borrowingFeeV2 = pendingHoldingFees.borrowingFeeCollateral;
+    const fundingFee = pendingHoldingFees.fundingFeeCollateral;
+    // Calculate closing fees
+    const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(trade.collateralIndex, trade.user, trade.pairIndex, positionSizeCollateral, trade.isCounterTrade || false, {
+        fee: context.trading.fee,
+        globalTradeFeeParams: context.trading.globalTradeFeeParams,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        traderFeeMultiplier: context.trading.traderFeeMultiplier,
+    });
+    // Total fees
+    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)
+        ? (0, liquidation_1.getLiqPnlThresholdP)(context.tradeData.liquidationParams, trade.leverage) *
+            -100
+        : -90; // Default 90% loss
+    const isLiquidated = rawPnlPercent <= liquidationThreshold;
+    // If liquidated, set both PnL percentages to -100%
+    if (isLiquidated) {
+        rawPnlPercent = -100;
+        impactPnlPercent = -100;
+    }
+    // Get realized PnL components from TradeFeesData
+    const { totalRealizedPnlCollateral } = (0, exports.getTradeRealizedPnlCollateral)(context.tradeData.tradeFeesData);
+    // Calculate raw PnL in collateral (using market price)
+    const rawPnlCollateral = trade.collateralAmount * (rawPnlPercent / 100);
+    // Calculate impact-adjusted PnL in collateral (using execution price)
+    const impactPnlCollateral = trade.collateralAmount * (impactPnlPercent / 100);
+    // Calculate price impact
+    const priceImpactCollateral = impactPnlCollateral - rawPnlCollateral;
+    const priceImpactPercent = impactPnlPercent - rawPnlPercent;
+    // Calculate unrealized PnL (before closing fee, after holding fees, using market price)
+    // This is what the trader sees for open positions
+    const uPnlCollateral = rawPnlCollateral - totalHoldingFees + totalRealizedPnlCollateral;
+    const uPnlPercent = (uPnlCollateral / trade.collateralAmount) * 100;
+    // Calculate realized PnL (after all fees including closing, using execution price)
+    // This is what the trader would get if closing the position
+    const realizedPnlCollateral = impactPnlCollateral - totalFees + totalRealizedPnlCollateral;
+    const realizedPnlPercent = (realizedPnlCollateral / trade.collateralAmount) * 100;
+    // Calculate trade value using execution price (what trader would receive)
+    const tradeValue = (0, exports.getTradeValue)(trade.collateralAmount, impactPnlPercent, totalFees);
+    return {
+        // Raw PnL values (using market price, no price impact)
+        pnlPercent: rawPnlPercent,
+        pnlCollateral: rawPnlCollateral,
+        // Impact-adjusted PnL values (using execution price)
+        impactPnlPercent,
+        impactPnlCollateral,
+        // Price impact
+        priceImpact: {
+            percent: priceImpactPercent,
+            collateral: priceImpactCollateral,
+        },
+        // Trade value (what trader would receive if closing)
+        tradeValue,
+        // Unrealized PnL (after holding fees, before closing fee, using market price)
+        // Use for open position display
+        uPnlCollateral,
+        uPnlPercent,
+        // Realized PnL (after all fees, using execution price)
+        // Use for closing preview
+        realizedPnlCollateral,
+        realizedPnlPercent,
+        // Fee breakdown
+        fees: {
+            borrowingV1: borrowingFeeV1,
+            borrowingV2: borrowingFeeV2,
+            funding: fundingFee,
+            closing: closingFee,
+            total: totalFees,
+        },
+        // Status flags
+        isLiquidated,
+        isProfitable: rawPnlPercent > 0, // Based on raw PnL
+    };
+};
+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 &&
+        context.pairs &&
+        context.groups &&
+        context.currentBlock !== undefined &&
+        context.collateralPriceUsd !== undefined) {
+        pnlCollat -= (0, borrowing_1.getBorrowingFee)(posCollat * trade.leverage, trade.pairIndex, trade.long, initialAccFees, price, {
+            currentBlock: context.currentBlock,
+            groups: context.groups,
+            pairs: context.pairs,
+            collateralPriceUsd: context.collateralPriceUsd,
+            pairOis: context.pairOis,
+        });
+    }
+    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, {
+            fee: context.fee,
+            globalTradeFeeParams: context.globalTradeFeeParams,
+            collateralPriceUsd: context.collateralPriceUsd || 1,
+            traderFeeMultiplier: context.traderFeeMultiplier,
+        });
+        pnlCollat -= closingFee;
+        pnlPercentage = (pnlCollat / posCollat) * 100;
+    }
+    pnlPercentage = pnlPercentage < -100 ? -100 : pnlPercentage;
+    pnlCollat = (posCollat * pnlPercentage) / 100;
+    return [pnlCollat, pnlPercentage];
+};
+exports.getPnl = getPnl;
+/**
+ * @dev Calculates the price needed to achieve a target PnL percentage
+ * @param targetPnlPercent The target PnL percentage (e.g., 50 for 50% profit, -25 for 25% loss)
+ * @param trade The trade to calculate for
+ * @param tradeInfo Trade info with timestamps
+ * @param context Context with fee calculation parameters
+ * @param netPnl Whether to include closing fees in the calculation
+ * @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) || {
+        realizedTradingFeesCollateral: 0,
+        realizedPnlCollateral: 0,
+        manuallyRealizedNegativePnlCollateral: 0,
+        alreadyTransferredNegativePnlCollateral: 0,
+        virtualAvailableCollateralInDiamond: 0,
+        initialAccFundingFeeP: 0,
+        initialAccBorrowingFeeP: 0,
+    }, openPrice, // Use open price as a baseline
+    {
+        contractsVersion: context.core.contractsVersion,
+        currentTimestamp: context.core.currentTimestamp,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        borrowingV1: context.borrowingV1,
+        borrowingV2: context.borrowingV2,
+        funding: context.funding,
+        initialAccFees: (_b = context.tradeData) === null || _b === void 0 ? void 0 : _b.initialAccFees,
+    });
+    const totalHoldingFees = fees.fundingFeeCollateral +
+        fees.borrowingFeeCollateral +
+        fees.borrowingFeeCollateral_old;
+    const targetPnlInCollateral = (collateralAmount * targetPnlPercent) / 100;
+    let targetPnlGross = targetPnlInCollateral + totalHoldingFees;
+    if (netPnl) {
+        // Include closing fees
+        const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(trade.collateralIndex, trade.user, trade.pairIndex, positionSizeCollateral, trade.isCounterTrade || false, {
+            fee: context.trading.fee,
+            globalTradeFeeParams: context.trading.globalTradeFeeParams,
+            collateralPriceUsd: context.core.collateralPriceUsd,
+            traderFeeMultiplier: context.trading.traderFeeMultiplier,
+        });
+        targetPnlGross += closingFee;
+    }
+    // Calculate the price
+    let price;
+    if (long) {
+        price = openPrice + (targetPnlGross * openPrice) / positionSizeCollateral;
+    }
+    else {
+        price = openPrice - (targetPnlGross * openPrice) / positionSizeCollateral;
+    }
+    return price;
+};
+exports.getPriceForTargetPnlPercentage = getPriceForTargetPnlPercentage;
+// Re-export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,79 @@
+/**
+ * @dev Types for PnL calculations
+ */
+import { ContractsVersion } from "src/contracts/types";
+import { BorrowingFee, GetBorrowingFeeContext, TradingFeesSubContext } from "../fees";
+import { GetPairBorrowingFeeV2Context } from "../fees/borrowingV2";
+import { GetPairFundingFeeContext } from "../fees/fundingFees";
+import { TradeFeesData, LiquidationParams } from "../types";
+/**
+ * @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;
+    impactPnlPercent: number;
+    impactPnlCollateral: number;
+    priceImpact: {
+        percent: number;
+        collateral: number;
+    };
+    tradeValue: number;
+    uPnlCollateral: number;
+    uPnlPercent: number;
+    realizedPnlCollateral: number;
+    realizedPnlPercent: number;
+    fees: FeeBreakdown;
+    isLiquidated: boolean;
+    isProfitable: boolean;
+};
+/**
+ * @dev Context for comprehensive PnL calculations with nested sub-contexts
+ */
+export type GetComprehensivePnlContext = {
+    core: {
+        currentBlock: number;
+        currentTimestamp: number;
+        collateralPriceUsd: number;
+        contractsVersion: ContractsVersion;
+    };
+    borrowingV1?: GetBorrowingFeeContext;
+    borrowingV2?: GetPairBorrowingFeeV2Context;
+    funding?: GetPairFundingFeeContext;
+    trading: TradingFeesSubContext;
+    tradeData?: {
+        tradeFeesData: TradeFeesData;
+        liquidationParams: LiquidationParams;
+        initialAccFees?: BorrowingFee.InitialAccFees;
+    };
+};

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/priceImpact/close/builder.d.ts

@@ -0,0 +1,23 @@
+import { GlobalTradingVariablesType } from "../../../backend/tradingVariables/types";
+import { TradeClosingPriceImpactContext } from "./types";
+import { TradeInfo } from "../../types";
+/**
+ * @dev Builds a complete context for trade closing price impact calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex The collateral index (1-based)
+ * @param pairIndex The pair index
+ * @param tradeInfo Trade information including createdBlock
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getTradeClosingPriceImpact
+ */
+export declare const buildTradeClosingPriceImpactContext: (globalTradingVariables: GlobalTradingVariablesType, collateralIndex: number, pairIndex: number, tradeInfo: TradeInfo, additionalParams: {
+    currentBlock: number;
+    contractsVersion?: number;
+    isPnlPositive?: boolean;
+    userPriceImpact?: {
+        cumulVolPriceImpactMultiplier: number;
+        fixedSpreadP: number;
+    };
+    protectionCloseFactorWhitelist?: boolean;
+}) => TradeClosingPriceImpactContext | undefined;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTradeClosingPriceImpactContext = void 0;
+const builder_1 = require("../cumulVol/builder");
+const builder_2 = require("../skew/builder");
+/**
+ * @dev Builds a complete context for trade closing price impact calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex The collateral index (1-based)
+ * @param pairIndex The pair index
+ * @param tradeInfo Trade information including createdBlock
+ * @param additionalParams Additional parameters not available in trading variables
+ * @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;
+    }
+    // Build cumulative volume subcontext for closing
+    const cumulVolContext = (0, builder_1.buildCumulVolContext)(globalTradingVariables, collateralIndex, pairIndex, {
+        currentBlock: additionalParams.currentBlock,
+        contractsVersion: additionalParams.contractsVersion || tradeInfo.contractsVersion,
+        isPnlPositive: additionalParams.isPnlPositive,
+        isOpen: false,
+        createdBlock: tradeInfo.createdBlock,
+        userPriceImpact: additionalParams.userPriceImpact,
+        protectionCloseFactorWhitelist: additionalParams.protectionCloseFactorWhitelist,
+    });
+    // Build skew price impact subcontext
+    const skewContext = (0, builder_2.buildSkewPriceImpactContext)(collateral, pairIndex);
+    if (!cumulVolContext || !skewContext) {
+        return undefined;
+    }
+    // Return structured context with proper subcontexts
+    return {
+        collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+        cumulVolContext,
+        skewContext,
+        tradeInfo,
+    };
+};
+exports.buildTradeClosingPriceImpactContext = buildTradeClosingPriceImpactContext;

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

@@ -0,0 +1,22 @@
+/**
+ * @dev Trade closing price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeClosingPriceImpact
+ */
+import { TradeClosingPriceImpactInput, TradeClosingPriceImpactContext, TradeClosingPriceImpactResult } from "./types";
+export type { TradeClosingPriceImpactInput, TradeClosingPriceImpactContext, TradeClosingPriceImpactResult, };
+export { buildTradeClosingPriceImpactContext } from "./builder";
+/**
+ * @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,134 @@
+"use strict";
+/**
+ * @dev Trade closing price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeClosingPriceImpact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeClosingPriceImpactAtOracle = exports.getTradeClosingPriceImpact = exports.buildTradeClosingPriceImpactContext = void 0;
+const cumulVol_1 = require("../cumulVol");
+const skew_1 = require("../skew");
+const types_1 = require("../../../contracts/types");
+const pnl_1 = require("../../pnl");
+const __1 = require("../");
+// Export builder
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildTradeClosingPriceImpactContext", { enumerable: true, get: function () { return builder_1.buildTradeClosingPriceImpactContext; } });
+/**
+ * @dev Calculates position size in tokens for the portion being closed
+ * @param positionSizeCollateral Position size in collateral units being closed
+ * @param originalPositionSizeToken Original total position size in tokens
+ * @param originalCollateral Original collateral amount
+ * @param originalLeverage Original leverage
+ * @returns Position size in tokens for the closing portion
+ */
+const calculateClosingPositionSizeToken = (positionSizeCollateral, originalPositionSizeToken, originalCollateral, originalLeverage) => {
+    const totalPositionSizeCollateral = originalCollateral * originalLeverage;
+    if (totalPositionSizeCollateral === 0)
+        return 0;
+    // (positionSizeCollateral * originalPositionSizeToken) / totalPositionSizeCollateral
+    return ((positionSizeCollateral * originalPositionSizeToken) /
+        totalPositionSizeCollateral);
+};
+/**
+ * @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,
+            baseSkewPriceImpactP: 0,
+            tradeSkewPriceImpactP: 0,
+            totalSkewPriceImpactP: 0,
+            totalPriceImpactP: 0,
+            totalPriceImpactPFromMarketPrice: 0,
+            priceAfterImpact: input.oraclePrice,
+            tradeValueCollateralNoFactor: 0,
+        };
+    }
+    // Calculate position size in tokens (proportional to collateral being closed)
+    const positionSizeToken = input.trade.positionSizeToken
+        ? calculateClosingPositionSizeToken(input.positionSizeCollateral, input.trade.positionSizeToken, input.trade.collateralAmount, input.trade.leverage)
+        : 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, context.cumulVolContext);
+        // Calculate price with conservative impact
+        const priceWithImpact = (0, __1.getPriceAfterImpact)(input.currentPairPrice, fixedSpreadP + cumulVolPriceImpactP);
+        // Calculate PnL percentage using the proper function
+        const pnlPercent = (0, pnl_1.getPnlPercent)(input.trade.openPrice, priceWithImpact, input.trade.long, input.trade.leverage);
+        // Calculate trade value using getTradeValue function
+        // Note: We don't include fees here as this is the raw trade value
+        tradeValueCollateralNoFactor = (0, pnl_1.getTradeValue)(input.trade.collateralAmount, pnlPercent, 0 // No fees for raw trade value calculation
+        );
+        // Determine actual PnL from the calculated percentage
+        const isPnlPositive = pnlPercent > 0;
+        // 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, context.cumulVolContext);
+        }
+    }
+    // Calculate skew price impact (v10+ only)
+    const skewPriceImpactObject = input.contractsVersion >= types_1.ContractsVersion.V10
+        ? (0, skew_1.getTradeSkewPriceImpact)({
+            collateralIndex: input.collateralIndex,
+            pairIndex: input.pairIndex,
+            long: input.trade.long,
+            open: false,
+            positionSizeToken,
+        }, context.skewContext)
+        : {
+            basePriceImpactP: 0,
+            tradePriceImpactP: 0,
+            totalPriceImpactP: 0,
+        };
+    // Total price impact (all components)
+    const totalPriceImpactP = fixedSpreadP +
+        cumulVolPriceImpactP +
+        skewPriceImpactObject.totalPriceImpactP;
+    const totalPriceImpactPFromMarketPrice = fixedSpreadP +
+        cumulVolPriceImpactP +
+        skewPriceImpactObject.tradePriceImpactP;
+    // Calculate final price after all impacts
+    const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.currentPairPrice, totalPriceImpactP);
+    return {
+        positionSizeToken,
+        fixedSpreadP,
+        cumulVolPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
+        totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
+        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,47 @@
+/**
+ * @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 = {
+    collateralPriceUsd: number;
+    cumulVolContext: CumulVolContext;
+    skewContext: SkewPriceImpactContext;
+    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;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
+    totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: 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 });