@gainsnetwork/sdk 0.0.0-v10.rc21 → 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/package.json

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