@gainsnetwork/sdk 0.0.0-v10.rc20 → 0.0.0-v10.rc22

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

@@ -25,7 +25,7 @@ const calculateClosingPositionSizeToken = (positionSizeCollateral, originalPosit
     const totalPositionSizeCollateral = originalCollateral * originalLeverage;
     if (totalPositionSizeCollateral === 0)
         return 0;
-    // Match contract logic: (positionSizeCollateral * originalPositionSizeToken) / totalPositionSizeCollateral
+    // (positionSizeCollateral * originalPositionSizeToken) / totalPositionSizeCollateral
     return ((positionSizeCollateral * originalPositionSizeToken) /
         totalPositionSizeCollateral);
 };
@@ -83,22 +83,18 @@ const getTradeClosingPriceImpact = (input, context) => {
         }
     }
     // Calculate skew price impact (v10+ only)
-    const skewPriceImpactP = input.contractsVersion === types_1.ContractsVersion.V10
-        ? (0, skew_1.getTradeSkewPriceImpactWithChecks)({
+    const skewPriceImpactP = input.contractsVersion >= types_1.ContractsVersion.V10
+        ? (0, skew_1.getTradeSkewPriceImpact)({
             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)
+            positionSizeToken,
+        }, context.skewContext).priceImpactP
         : 0;
     // Total price impact (all components)
     const totalPriceImpactP = fixedSpreadP + cumulVolPriceImpactP + skewPriceImpactP;
     // Calculate final price after all impacts
-    // The direction is already handled by getFixedSpreadP (reverses for closing)
     const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.currentPairPrice, totalPriceImpactP);
     return {
         positionSizeToken,

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

@@ -15,7 +15,7 @@ export { getTradeClosingPriceImpact, getTradeClosingPriceImpactAtOracle, buildTr
 export { getTradeCumulVolPriceImpactP, getCumulVolPriceImpact, // Convenience function
 getSpreadWithCumulVolPriceImpactP, getSpreadWithPriceImpactP, // Legacy alias
 getProtectionCloseFactor, isProtectionCloseFactorActive, getCumulativeFactor, getLegacyFactor, getFixedSpreadP, getSpreadP, convertOiWindowsSettings, convertOiWindow, convertOiWindows, convertOiWindowsSettingsArray, buildCumulVolContext, CumulVolContext, } from "./cumulVol";
-export { getNetSkewToken, getNetSkewCollateral, getTradeSkewDirection, calculateSkewPriceImpactP, getTradeSkewPriceImpact, getTradeSkewPriceImpactWithChecks, calculatePartialSizeToken, SkewPriceImpact, } from "./skew";
+export { getNetSkewToken, getNetSkewCollateral, getTradeSkewDirection, calculateSkewPriceImpactP, getTradeSkewPriceImpact, calculatePartialSizeToken, SkewPriceImpact, } from "./skew";
 export { convertPairOiToken, convertPairOiTokenArray, convertPairOiCollateral, convertPairOiCollateralArray, convertSkewDepth, convertPairSkewDepths, } from "./skew/converter";
 export { buildSkewPriceImpactContext } from "./skew/builder";
 export type { PairOiToken, PairOiCollateral, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext, TradeSkewParams, PositionSizeResult, } from "./skew/types";

package/lib/trade/priceImpact/index.js

@@ -4,7 +4,7 @@
  * @dev Exports cumulative volume, skew, and combined opening/closing price impact functionality
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSkewPriceImpactContext = exports.convertPairSkewDepths = exports.convertSkewDepth = exports.convertPairOiCollateralArray = exports.convertPairOiCollateral = exports.convertPairOiTokenArray = exports.convertPairOiToken = exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpactWithChecks = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = exports.buildCumulVolContext = exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = exports.getSpreadP = exports.getFixedSpreadP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = exports.getSpreadWithPriceImpactP = exports.getSpreadWithCumulVolPriceImpactP = exports.getCumulVolPriceImpact = exports.getTradeCumulVolPriceImpactP = exports.buildTradeClosingPriceImpactContext = exports.getTradeClosingPriceImpactAtOracle = exports.getTradeClosingPriceImpact = exports.buildTradeOpeningPriceImpactContext = exports.getTradeOpeningPriceImpactAtMarket = exports.getTradeOpeningPriceImpact = exports.getPriceAfterImpact = void 0;
+exports.buildSkewPriceImpactContext = exports.convertPairSkewDepths = exports.convertSkewDepth = exports.convertPairOiCollateralArray = exports.convertPairOiCollateral = exports.convertPairOiTokenArray = exports.convertPairOiToken = exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = exports.buildCumulVolContext = exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = exports.getSpreadP = exports.getFixedSpreadP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = exports.getSpreadWithPriceImpactP = exports.getSpreadWithCumulVolPriceImpactP = exports.getCumulVolPriceImpact = exports.getTradeCumulVolPriceImpactP = exports.buildTradeClosingPriceImpactContext = exports.getTradeClosingPriceImpactAtOracle = exports.getTradeClosingPriceImpact = exports.buildTradeOpeningPriceImpactContext = exports.getTradeOpeningPriceImpactAtMarket = exports.getTradeOpeningPriceImpact = exports.getPriceAfterImpact = void 0;
 /**
  * @dev Calculates price after impact using the same formula as the Solidity contract
  * @dev Mirrors contract's getPriceAfterImpact function
@@ -63,7 +63,6 @@ Object.defineProperty(exports, "getNetSkewCollateral", { enumerable: true, get:
 Object.defineProperty(exports, "getTradeSkewDirection", { enumerable: true, get: function () { return skew_1.getTradeSkewDirection; } });
 Object.defineProperty(exports, "calculateSkewPriceImpactP", { enumerable: true, get: function () { return skew_1.calculateSkewPriceImpactP; } });
 Object.defineProperty(exports, "getTradeSkewPriceImpact", { enumerable: true, get: function () { return skew_1.getTradeSkewPriceImpact; } });
-Object.defineProperty(exports, "getTradeSkewPriceImpactWithChecks", { enumerable: true, get: function () { return skew_1.getTradeSkewPriceImpactWithChecks; } });
 Object.defineProperty(exports, "calculatePartialSizeToken", { enumerable: true, get: function () { return skew_1.calculatePartialSizeToken; } });
 // Types namespace
 Object.defineProperty(exports, "SkewPriceImpact", { enumerable: true, get: function () { return skew_1.SkewPriceImpact; } });

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

@@ -31,19 +31,20 @@ const getTradeOpeningPriceImpact = (input, context) => {
     true, // open
     0, // lastPosIncreaseBlock - not relevant for opening
     context.cumulVolContext);
+    // Calculate price after spread and cumulative volume impact (before skew)
+    const priceAfterSpreadAndCumulVolPriceImpact = (0, __1.getPriceAfterImpact)(input.openPrice, spreadP + cumulVolPriceImpactP);
+    // 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 skewPriceImpactP = (0, skew_1.getTradeSkewPriceImpactWithChecks)({
+    const skewResult = (0, skew_1.getTradeSkewPriceImpact)({
         collateralIndex: input.collateralIndex,
         pairIndex: input.pairIndex,
         long: input.long,
         open: true,
-        positionSizeCollateral,
-        currentPrice: input.openPrice,
-        contractsVersion: input.contractsVersion,
-        isCounterTrade: input.isCounterTrade,
+        positionSizeToken,
     }, context.skewContext);
+    const skewPriceImpactP = skewResult.priceImpactP;
     // Total price impact (signed - can be positive or negative)
-    // Spread is always positive, impacts can be negative
     const totalPriceImpactP = spreadP + cumulVolPriceImpactP + skewPriceImpactP;
     // Calculate final price after impact using the same formula as Solidity
     const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.openPrice, totalPriceImpactP);
@@ -53,7 +54,6 @@ const getTradeOpeningPriceImpact = (input, context) => {
     const percentProfitP = -totalPriceImpactP;
     return {
         priceAfterImpact,
-        priceImpactP: Math.abs(totalPriceImpactP),
         percentProfitP,
         cumulVolPriceImpactP,
         skewPriceImpactP,

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

@@ -34,7 +34,6 @@ export type TradeOpeningPriceImpactContext = {
  */
 export type TradeOpeningPriceImpactResult = {
     priceAfterImpact: number;
-    priceImpactP: number;
     percentProfitP: number;
     cumulVolPriceImpactP: number;
     skewPriceImpactP: number;

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

@@ -2,7 +2,7 @@
  * @dev Skew price impact calculations for v10+ trades
  * @dev Based on formula: (existingSkew + tradeSize/2) / skewDepth
  */
-import { PairOiToken, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext, TradeSkewParams } from "./types";
+import { PairOiToken, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext } from "./types";
 /**
  * @dev Calculates net skew in tokens (long - short)
  * @param pairOi Pair OI data with long and short token amounts
@@ -28,10 +28,10 @@ export declare const getTradeSkewDirection: (long: boolean, open: boolean) => bo
  * @param existingSkewToken Current net skew in tokens (signed)
  * @param tradeSizeToken Trade size in tokens (always positive)
  * @param skewDepth Skew depth in tokens
- * @param tradeIncreasesSkew Whether trade increases skew in its direction
+ * @param tradePositiveSkew Whether trade increases skew in its direction
  * @returns Price impact percentage (can be positive or negative)
  */
-export declare const calculateSkewPriceImpactP: (existingSkewToken: number, tradeSizeToken: number, skewDepth: number, tradeIncreasesSkew: boolean) => number;
+export declare const calculateSkewPriceImpactP: (existingSkewToken: number, tradeSizeToken: number, skewDepth: number, tradePositiveSkew: boolean) => number;
 /**
  * @dev Main function to calculate skew price impact for a trade
  * @param input Trade parameters
@@ -39,13 +39,6 @@ export declare const calculateSkewPriceImpactP: (existingSkewToken: number, trad
  * @returns Skew price impact result
  */
 export declare const getTradeSkewPriceImpact: (input: SkewPriceImpactInput, context: SkewPriceImpactContext) => SkewPriceImpactResult;
-/**
- * @dev Calculate skew price impact for a trade with all parameters
- * @param params Trade parameters including price and version checks
- * @param context Skew price impact context
- * @returns Price impact percentage or 0 if not applicable
- */
-export declare const getTradeSkewPriceImpactWithChecks: (params: TradeSkewParams, context: SkewPriceImpactContext) => number;
 /**
  * @dev Calculate position sizes for partial operations
  * @param originalSizeCollateral Original position size in collateral

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

@@ -30,9 +30,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.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpactWithChecks = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
-const utils_1 = require("../../utils");
-const types_1 = require("../../../contracts/types");
+exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
 // Constants
 const PRICE_IMPACT_DIVIDER = 2; // Half price impact to match cumulative volume impact scale
 /**
@@ -71,18 +69,18 @@ exports.getTradeSkewDirection = getTradeSkewDirection;
  * @param existingSkewToken Current net skew in tokens (signed)
  * @param tradeSizeToken Trade size in tokens (always positive)
  * @param skewDepth Skew depth in tokens
- * @param tradeIncreasesSkew Whether trade increases skew in its direction
+ * @param tradePositiveSkew Whether trade increases skew in its direction
  * @returns Price impact percentage (can be positive or negative)
  */
-const calculateSkewPriceImpactP = (existingSkewToken, tradeSizeToken, skewDepth, tradeIncreasesSkew) => {
+const calculateSkewPriceImpactP = (existingSkewToken, tradeSizeToken, skewDepth, tradePositiveSkew) => {
     if (skewDepth === 0) {
         return 0; // No impact if depth is 0
     }
     // Convert signed values based on trade direction
-    const tradeSkewMultiplier = tradeIncreasesSkew ? 1 : -1;
+    const tradeSkewMultiplier = tradePositiveSkew ? 1 : -1;
     const signedExistingSkew = existingSkewToken;
     const signedTradeSize = tradeSizeToken * tradeSkewMultiplier;
-    // Formula: (existingSkew + tradeSize/2) / skewDepth
+    // (existingSkew + tradeSize/2) / skewDepth
     const numerator = signedExistingSkew + signedTradeSize / 2;
     const priceImpactP = numerator / skewDepth;
     // Apply divider to match cumulative volume impact scale
@@ -100,10 +98,10 @@ const getTradeSkewPriceImpact = (input, context) => {
     const { skewDepth, pairOiToken: pairOi } = context;
     // Calculate net skew
     const netSkewToken = (0, exports.getNetSkewToken)(pairOi);
-    // Determine trade direction impact
-    const tradeIncreasesSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
+    // Determine trade direction
+    const tradePositiveSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
     // Calculate price impact
-    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradeIncreasesSkew);
+    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradePositiveSkew);
     // Determine trade direction relative to skew
     let tradeDirection;
     if (priceImpactP > 0) {
@@ -123,34 +121,6 @@ const getTradeSkewPriceImpact = (input, context) => {
     };
 };
 exports.getTradeSkewPriceImpact = getTradeSkewPriceImpact;
-/**
- * @dev Calculate skew price impact for a trade with all parameters
- * @param params Trade parameters including price and version checks
- * @param context Skew price impact context
- * @returns Price impact percentage or 0 if not applicable
- */
-const getTradeSkewPriceImpactWithChecks = (params, context) => {
-    // v10+ trades only
-    if (params.contractsVersion < types_1.ContractsVersion.V10) {
-        return 0;
-    }
-    // Counter trades don't pay skew impact
-    if (params.isCounterTrade) {
-        return 0;
-    }
-    // Calculate position size in tokens
-    const positionSizeToken = (0, utils_1.calculatePositionSizeToken)(params.positionSizeCollateral, params.currentPrice);
-    // Get skew price impact
-    const result = (0, exports.getTradeSkewPriceImpact)({
-        collateralIndex: params.collateralIndex,
-        pairIndex: params.pairIndex,
-        long: params.long,
-        open: params.open,
-        positionSizeToken,
-    }, context);
-    return result.priceImpactP;
-};
-exports.getTradeSkewPriceImpactWithChecks = getTradeSkewPriceImpactWithChecks;
 /**
  * @dev Calculate position sizes for partial operations
  * @param originalSizeCollateral Original position size in collateral

package/package.json

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