@gainsnetwork/sdk 0.2.67-rc6 → 0.2.67-rc8

package/lib/trade/pnl/index.js

@@ -0,0 +1,270 @@
+"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 = void 0;
+const borrowing_1 = require("../fees/borrowing");
+const trading_1 = require("../fees/trading");
+const liquidation_1 = require("../liquidation");
+/**
+ * @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) => {
+    var _a;
+    // Calculate base PnL percentage
+    let pnlPercent = (0, exports.getPnlPercent)(trade.openPrice, currentPrice, 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
+    // This mirrors the contract's getTradeValueCollateral which always calls this function
+    const pendingHoldingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeData.tradeFeesData, currentPrice, {
+        contractsVersion: context.core.contractsVersion,
+        currentTimestamp: context.core.currentTimestamp,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        borrowingV1: context.borrowingV1,
+        borrowingV2: context.borrowingV2,
+        funding: context.funding,
+        initialAccFeesV1: context.tradeData.initialAccFeesV1,
+    });
+    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 totalFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee + closingFee;
+    // Check liquidation
+    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 = 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;
+    // Calculate unrealized PnL (before closing fee, after holding fees)
+    const totalHoldingFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee;
+    const uPnlCollateral = pnlCollateral - totalHoldingFees;
+    const uPnlPercent = (uPnlCollateral / trade.collateralAmount) * 100;
+    // Realized PnL (after all fees including closing)
+    const realizedPnlCollateral = pnlCollateral - totalFees;
+    const realizedPnlPercent = (realizedPnlCollateral / trade.collateralAmount) * 100;
+    return {
+        // Core PnL values
+        pnlPercent,
+        pnlCollateral,
+        tradeValue,
+        // Unrealized PnL (after holding fees, before closing fee)
+        uPnlCollateral,
+        uPnlPercent,
+        // Realized PnL (after all fees)
+        realizedPnlCollateral,
+        realizedPnlPercent,
+        // 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 &&
+        context.pairs &&
+        context.groups &&
+        context.currentBlock !== undefined &&
+        context.collateralPriceUsd !== undefined) {
+        pnlCollat -= (0, borrowing_1.getBorrowingFee)(posCollat * trade.leverage, trade.pairIndex, trade.long, initialAccFees, {
+            currentBlock: context.currentBlock,
+            groups: context.groups,
+            pairs: context.pairs,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    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,
+        initialAccFeesV1: (_b = context.tradeData) === null || _b === void 0 ? void 0 : _b.initialAccFeesV1,
+    });
+    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,114 @@
+/**
+ * @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 { Trade, TradeInfo, TradeFeesData, LiquidationParams } 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;
+    uPnlCollateral: number;
+    uPnlPercent: number;
+    realizedPnlCollateral: number;
+    realizedPnlPercent: 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;
+};
+/**
+ * @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;
+        initialAccFeesV1?: 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/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[];