@gainsnetwork/sdk 0.0.0-v10.rc21 → 0.0.0-v10.rc23

package/lib/markets/price/marketPrice.d.ts

@@ -4,6 +4,7 @@
 import { MarketPriceResult, MarketPriceContext } from "./types";
 /**
  * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
  * @param pairIndex Trading pair index
  * @param oraclePrice Oracle price for the pair
  * @param context Market price context with depths and OI data

package/lib/markets/price/marketPrice.js

@@ -7,6 +7,7 @@ exports.getCurrentMarketPrice = void 0;
 const skew_1 = require("../../trade/priceImpact/skew");
 /**
  * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
  * @param pairIndex Trading pair index
  * @param oraclePrice Oracle price for the pair
  * @param context Market price context with depths and OI data
@@ -22,7 +23,7 @@ const getCurrentMarketPrice = (pairIndex, oraclePrice, context) => {
             open: true,
             positionSizeToken: 0, // Size 0 for current market price
         }, context);
-        skewImpactP = skewResult.priceImpactP;
+        skewImpactP = skewResult.basePriceImpactP;
     }
     const marketPrice = oraclePrice * (1 + skewImpactP / 100);
     return {

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

@@ -10,6 +10,19 @@ import { GetLiquidationPriceContext } from "./types";
  * @returns Liquidation price
  */
 export declare const getLiquidationPrice: (trade: Trade, context: GetLiquidationPriceContext) => number;
+/**
+ * @dev Calculate liquidation price after a position size update
+ * @dev Mirrors the contract's IncreasePositionSizeUtils.sol and DecreasePositionSizeUtils.sol logic
+ * @param existingTrade The current trade before the update
+ * @param newCollateralAmount New collateral amount after the update
+ * @param newLeverage New leverage after the update
+ * @param isLeverageUpdate Whether this is a leverage update vs regular position change
+ * @param positionSizeCollateralDelta The absolute change in position size (in collateral terms)
+ * @param pnlToRealizeCollateral PnL to be realized (only relevant for leverage decrease)
+ * @param context Structured context with all required data (including additionalFeesCollateral for increases)
+ * @returns New liquidation price after the update
+ */
+export declare const getLiquidationPriceAfterPositionUpdate: (existingTrade: Trade, newCollateralAmount: number, newLeverage: number, isLeverageUpdate: boolean, positionSizeCollateralDelta: number, pnlToRealizeCollateral: number, context: GetLiquidationPriceContext) => number;
 export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;
 export { convertLiquidationParams, convertLiquidationParamsArray, encodeLiquidationParams, } from "./converter";
 export * from "./types";

package/lib/trade/liquidation/index.js

@@ -17,7 +17,7 @@ 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.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
+exports.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getLiqPnlThresholdP = exports.getLiquidationPriceAfterPositionUpdate = exports.getLiquidationPrice = void 0;
 const types_1 = require("../../contracts/types");
 const __1 = require("..");
 /**
@@ -86,6 +86,101 @@ const getLiquidationPrice = (trade, context) => {
         : Math.max(trade.openPrice + liqPriceDistance, 0);
 };
 exports.getLiquidationPrice = getLiquidationPrice;
+/**
+ * @dev Calculate liquidation price after a position size update
+ * @dev Mirrors the contract's IncreasePositionSizeUtils.sol and DecreasePositionSizeUtils.sol logic
+ * @param existingTrade The current trade before the update
+ * @param newCollateralAmount New collateral amount after the update
+ * @param newLeverage New leverage after the update
+ * @param isLeverageUpdate Whether this is a leverage update vs regular position change
+ * @param positionSizeCollateralDelta The absolute change in position size (in collateral terms)
+ * @param pnlToRealizeCollateral PnL to be realized (only relevant for leverage decrease)
+ * @param context Structured context with all required data (including additionalFeesCollateral for increases)
+ * @returns New liquidation price after the update
+ */
+const getLiquidationPriceAfterPositionUpdate = (existingTrade, newCollateralAmount, newLeverage, isLeverageUpdate, positionSizeCollateralDelta, pnlToRealizeCollateral, context) => {
+    var _a, _b;
+    const { currentPairPrice, isCounterTrade = false } = context.liquidationSpecific;
+    // 1. Calculate closing fees on the NEW position size
+    const closingFeeCollateral = (0, __1.getTotalTradeFeesCollateral)(existingTrade.collateralIndex, "", // No fee tiers applied for liquidation calculation
+    existingTrade.pairIndex, newCollateralAmount * newLeverage, isCounterTrade, {
+        fee: context.trading.fee,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        globalTradeFeeParams: context.trading.globalTradeFeeParams,
+        traderFeeMultiplier: 1,
+        counterTradeSettings: context.trading.counterTradeSettings,
+    });
+    // 2. Calculate holding fees on the EXISTING trade (full position)
+    const holdingFees = (0, __1.getTradePendingHoldingFeesCollateral)(existingTrade, context.tradeData.tradeInfo, context.tradeData.tradeFeesData, currentPairPrice, {
+        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,
+    });
+    // 3. Calculate total realized PnL
+    const totalRealizedPnlCollateral = context.tradeData.tradeFeesData.realizedPnlCollateral -
+        context.tradeData.tradeFeesData.realizedTradingFeesCollateral;
+    // 4. Determine if this is an increase or decrease
+    const existingPositionSizeCollateral = existingTrade.collateralAmount * existingTrade.leverage;
+    const newPositionSizeCollateral = newCollateralAmount * newLeverage;
+    const isIncrease = newPositionSizeCollateral > existingPositionSizeCollateral;
+    // 5. Calculate additional fee and partial close multiplier based on update type
+    let additionalFeeCollateral;
+    let partialCloseMultiplier;
+    if (isIncrease) {
+        // For position increases: use additional fees from context (e.g., opening fees), no partial close
+        additionalFeeCollateral =
+            context.liquidationSpecific.additionalFeeCollateral || 0;
+        partialCloseMultiplier = 0; // Not a partial close
+    }
+    else if (isLeverageUpdate) {
+        // For leverage decreases: additional fee includes closing fee minus PnL to realize
+        additionalFeeCollateral = closingFeeCollateral - pnlToRealizeCollateral;
+        partialCloseMultiplier = 1; // Full multiplier for leverage updates
+    }
+    else {
+        // For regular position decreases: no additional fee, scaled multiplier
+        additionalFeeCollateral = 0;
+        partialCloseMultiplier =
+            (existingPositionSizeCollateral - positionSizeCollateralDelta) /
+                existingPositionSizeCollateral;
+    }
+    // 6. Calculate total fees
+    const totalFeesCollateral = closingFeeCollateral +
+        (holdingFees.totalFeeCollateral - totalRealizedPnlCollateral) *
+            partialCloseMultiplier +
+        additionalFeeCollateral;
+    // 7. Calculate liquidation threshold
+    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.tradeData.liquidationParams, newLeverage);
+    // 8. Calculate liquidation price distance
+    const collateralLiqNegativePnl = newCollateralAmount * liqThresholdP;
+    // For increases, we need to use the new weighted average open price
+    // For decreases, we use the existing open price
+    const openPriceToUse = isIncrease
+        ? context.liquidationSpecific.newOpenPrice || existingTrade.openPrice
+        : existingTrade.openPrice;
+    let liqPriceDistance = (openPriceToUse * (collateralLiqNegativePnl - totalFeesCollateral)) /
+        newCollateralAmount /
+        newLeverage;
+    // 9. Apply closing spread for v9.2+
+    if (context.core.contractsVersion >= types_1.ContractsVersion.V9_2 &&
+        ((((_a = context.tradeData.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
+            context.tradeData.liquidationParams.maxLiqSpreadP > 0) ||
+            (((_b = context.liquidationSpecific.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !==
+                undefined &&
+                context.liquidationSpecific.userPriceImpact.fixedSpreadP > 0))) {
+        const closingSpreadP = (0, __1.getSpreadP)(context.core.spreadP, true, context.tradeData.liquidationParams, context.liquidationSpecific.userPriceImpact);
+        liqPriceDistance -= openPriceToUse * closingSpreadP;
+    }
+    // 10. Calculate final liquidation price
+    return existingTrade.long
+        ? Math.max(openPriceToUse - liqPriceDistance, 0)
+        : Math.max(openPriceToUse + liqPriceDistance, 0);
+};
+exports.getLiquidationPriceAfterPositionUpdate = getLiquidationPriceAfterPositionUpdate;
 const getLiqPnlThresholdP = (liquidationParams, leverage) => {
     if (liquidationParams === undefined ||
         leverage === undefined ||

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

@@ -38,5 +38,6 @@ export type GetLiquidationPriceContext = {
         beforeOpened: boolean;
         isCounterTrade: boolean;
         userPriceImpact?: UserPriceImpact;
+        newOpenPrice?: number;
     };
 };

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

@@ -39,12 +39,13 @@ export declare const getTradeValue: (collateral: number, pnlPercent: number, tot
 /**
  * @dev Comprehensive PnL calculation including all fees
  * @param trade The trade to calculate PnL for
- * @param currentPrice Current market price
+ * @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
  */
-export declare const getComprehensivePnl: (trade: Trade, currentPrice: number, tradeInfo: TradeInfo, context: GetComprehensivePnlContext) => ComprehensivePnlResult;
+export declare const getComprehensivePnl: (trade: Trade, marketPrice: number, executionPrice: number, tradeInfo: TradeInfo, context: GetComprehensivePnlContext) => ComprehensivePnlResult;
 /**
  * @dev Legacy getPnl function for backward compatibility
  * @deprecated Use getComprehensivePnl for new implementations

package/lib/trade/pnl/index.js

@@ -74,23 +74,24 @@ exports.getTradeValue = getTradeValue;
 /**
  * @dev Comprehensive PnL calculation including all fees
  * @param trade The trade to calculate PnL for
- * @param currentPrice Current market price
+ * @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, currentPrice, tradeInfo, context) => {
+const getComprehensivePnl = (trade, marketPrice, executionPrice, tradeInfo, context) => {
     var _a;
-    // Calculate base PnL percentage
-    let pnlPercent = (0, exports.getPnlPercent)(trade.openPrice, currentPrice, trade.long, trade.leverage);
+    // 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
-    // This mirrors the contract's getTradeValueCollateral which always calls this function
-    const pendingHoldingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeData.tradeFeesData, currentPrice, {
+    const pendingHoldingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeData.tradeFeesData, executionPrice, {
         contractsVersion: context.core.contractsVersion,
         currentTimestamp: context.core.currentTimestamp,
         collateralPriceUsd: context.core.collateralPriceUsd,
@@ -112,39 +113,56 @@ const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
     // Total fees
     const totalHoldingFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee;
     const totalFees = totalHoldingFees + closingFee;
-    // Check liquidation
+    // 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 = pnlPercent <= liquidationThreshold;
-    // If liquidated, set PnL to -100%
+    const isLiquidated = rawPnlPercent <= liquidationThreshold;
+    // If liquidated, set both PnL percentages to -100%
     if (isLiquidated) {
-        pnlPercent = -100;
+        rawPnlPercent = -100;
+        impactPnlPercent = -100;
     }
     // Get realized PnL components from TradeFeesData
     const { totalRealizedPnlCollateral } = (0, exports.getTradeRealizedPnlCollateral)(context.tradeData.tradeFeesData);
-    // 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 unrealized PnL (before closing fee, after holding fees)
-    const uPnlCollateral = pnlCollateral - totalHoldingFees + totalRealizedPnlCollateral;
+    // 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;
-    // Realized PnL (after all fees including closing)
-    const realizedPnlCollateral = pnlCollateral - totalFees + totalRealizedPnlCollateral;
+    // 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 {
-        // Core PnL values
-        pnlPercent,
-        pnlCollateral,
+        // 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)
+        // Unrealized PnL (after holding fees, before closing fee, using market price)
+        // Use for open position display
         uPnlCollateral,
         uPnlPercent,
-        // Realized PnL (after all fees)
+        // Realized PnL (after all fees, using execution price)
+        // Use for closing preview
         realizedPnlCollateral,
         realizedPnlPercent,
         // Fee breakdown
@@ -157,9 +175,7 @@ const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
         },
         // Status flags
         isLiquidated,
-        isProfitable: pnlPercent > 0,
-        // Additional info
-        leveragedPositionSize,
+        isProfitable: rawPnlPercent > 0, // Based on raw PnL
     };
 };
 exports.getComprehensivePnl = getComprehensivePnl;

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

@@ -42,16 +42,20 @@ export type PriceImpactBreakdown = {
 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;
-    priceImpact?: PriceImpactBreakdown;
     isLiquidated: boolean;
     isProfitable: boolean;
-    leveragedPositionSize: number;
 };
 /**
  * @dev Context for comprehensive PnL calculations with nested sub-contexts

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

@@ -43,8 +43,11 @@ const getTradeClosingPriceImpact = (input, context) => {
             positionSizeToken: 0,
             fixedSpreadP: 0,
             cumulVolPriceImpactP: 0,
-            skewPriceImpactP: 0,
+            baseSkewPriceImpactP: 0,
+            tradeSkewPriceImpactP: 0,
+            totalSkewPriceImpactP: 0,
             totalPriceImpactP: 0,
+            totalPriceImpactPFromMarketPrice: 0,
             priceAfterImpact: input.oraclePrice,
             tradeValueCollateralNoFactor: 0,
         };
@@ -83,25 +86,37 @@ const getTradeClosingPriceImpact = (input, context) => {
         }
     }
     // Calculate skew price impact (v10+ only)
-    const skewPriceImpactP = input.contractsVersion >= types_1.ContractsVersion.V10
+    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).priceImpactP
-        : 0;
+        }, context.skewContext)
+        : {
+            basePriceImpactP: 0,
+            tradePriceImpactP: 0,
+            totalPriceImpactP: 0,
+        };
     // Total price impact (all components)
-    const totalPriceImpactP = fixedSpreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    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,
-        skewPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
         totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
         priceAfterImpact,
         tradeValueCollateralNoFactor,
     };

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

@@ -37,8 +37,11 @@ export type TradeClosingPriceImpactResult = {
     positionSizeToken: number;
     fixedSpreadP: number;
     cumulVolPriceImpactP: number;
-    skewPriceImpactP: number;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
     totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: number;
     priceAfterImpact: number;
     tradeValueCollateralNoFactor: number;
 };

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

@@ -36,16 +36,17 @@ const getTradeOpeningPriceImpact = (input, context) => {
     // Calculate position size in tokens using the price after fixed spread and cumul vol impact
     const positionSizeToken = positionSizeCollateral / priceAfterSpreadAndCumulVolPriceImpact;
     // Calculate skew price impact (v10+ only)
-    const skewResult = (0, skew_1.getTradeSkewPriceImpact)({
+    const skewPriceImpactObject = (0, skew_1.getTradeSkewPriceImpact)({
         collateralIndex: input.collateralIndex,
         pairIndex: input.pairIndex,
         long: input.long,
         open: true,
         positionSizeToken,
     }, context.skewContext);
-    const skewPriceImpactP = skewResult.priceImpactP;
+    const skewPriceImpactP = skewPriceImpactObject.totalPriceImpactP;
     // Total price impact (signed - can be positive or negative)
     const totalPriceImpactP = spreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    const totalPriceImpactPFromMarketPrice = spreadP + cumulVolPriceImpactP + skewPriceImpactObject.tradePriceImpactP;
     // Calculate final price after impact using the same formula as Solidity
     const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.openPrice, totalPriceImpactP);
     // Calculate percent profit from impact
@@ -56,8 +57,11 @@ const getTradeOpeningPriceImpact = (input, context) => {
         priceAfterImpact,
         percentProfitP,
         cumulVolPriceImpactP,
-        skewPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
         totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
     };
 };
 exports.getTradeOpeningPriceImpact = getTradeOpeningPriceImpact;

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

@@ -36,6 +36,9 @@ export type TradeOpeningPriceImpactResult = {
     priceAfterImpact: number;
     percentProfitP: number;
     cumulVolPriceImpactP: number;
-    skewPriceImpactP: number;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
     totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: number;
 };

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

@@ -101,20 +101,25 @@ const getTradeSkewPriceImpact = (input, context) => {
     // Determine trade direction
     const tradePositiveSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
     // Calculate price impact
-    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradePositiveSkew);
+    const basePriceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, 0, skewDepth, tradePositiveSkew);
+    // Calculate price impact
+    const totalPriceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradePositiveSkew);
+    const tradePriceImpactP = totalPriceImpactP - basePriceImpactP;
     // Determine trade direction relative to skew
     let tradeDirection;
-    if (priceImpactP > 0) {
+    if (totalPriceImpactP > 0) {
         tradeDirection = "increase";
     }
-    else if (priceImpactP < 0) {
+    else if (totalPriceImpactP < 0) {
         tradeDirection = "decrease";
     }
     else {
         tradeDirection = "neutral";
     }
     return {
-        priceImpactP,
+        basePriceImpactP,
+        tradePriceImpactP,
+        totalPriceImpactP,
         netSkewToken,
         netSkewCollateral: 0,
         tradeDirection,

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

@@ -17,7 +17,9 @@ export type SkewPriceImpactInput = {
     positionSizeToken: number;
 };
 export type SkewPriceImpactResult = {
-    priceImpactP: number;
+    basePriceImpactP: number;
+    tradePriceImpactP: number;
+    totalPriceImpactP: number;
     netSkewToken: number;
     netSkewCollateral: number;
     tradeDirection: "increase" | "decrease" | "neutral";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.0.0-v10.rc21",
+  "version": "0.0.0-v10.rc23",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [