@gainsnetwork/sdk 0.0.0-v10.rc3 → 0.0.0-v10.rc5

package/lib/trade/fees/trading/index.js

@@ -18,10 +18,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradePendingHoldingFeesCollateral = exports.getClosingFee = exports.getTotalTradeLiqFeesCollateral = exports.getTradeFeesCollateral = exports.getTotalTradeFeesCollateral = void 0;
-const tiers_1 = require("../tiers");
-const fundingFees_1 = require("../fundingFees");
-const borrowingV2_1 = require("../borrowingV2");
 const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+const tiers_1 = require("../tiers");
 const types_1 = require("../../../contracts/types");
 /**
  * @dev Returns the total fee for a trade in collateral tokens
@@ -109,29 +109,36 @@ exports.getClosingFee = getClosingFee;
  * @param tradeInfo Trade info containing contracts version
  * @param tradeFeesData Trade fees data containing initial acc fees
  * @param currentPairPrice Current pair price
- * @param context Context with fee parameters
+ * @param context Structured context with sub-contexts for each fee type
  * @returns Object containing all holding fee components
  */
 const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
-    var _a;
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
     // Calculate funding fees (v10+ only)
-    const fundingFeeCollateral = ((_a = context.contractsVersion) !== null && _a !== void 0 ? _a : tradeInfo.contractsVersion) >=
-        types_1.ContractsVersion.V10
-        ? (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, context)
-        : 0;
-    // Calculate borrowing fees v2
-    const borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
-        positionSizeCollateral: trade.collateralAmount * trade.leverage,
-        openPrice: trade.openPrice,
-        collateralIndex: trade.collateralIndex,
-        pairIndex: trade.pairIndex,
-        currentPairPrice,
-        initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
-        currentTimestamp: context.currentTimestamp,
-    }, context);
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }));
+    }
+    // Calculate borrowing fees v2 (v10+ only)
+    let borrowingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.borrowingV2 &&
+        tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
     // Calculate v1 borrowing fees (some markets use v1 indefinitely)
-    const borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, context.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, // Use context initial fees or empty
-    context);
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1 && context.initialAccFees) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, trade.pairIndex, trade.long, context.initialAccFees, context.borrowingV1);
+    }
     return {
         fundingFeeCollateral,
         borrowingFeeCollateral,
@@ -145,3 +152,4 @@ exports.getTradePendingHoldingFeesCollateral = getTradePendingHoldingFeesCollate
 // Export types
 __exportStar(require("./types"), exports);
 __exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,25 @@
+/**
+ * @dev Liquidation price context builder module
+ * @dev Provides builder functions for creating liquidation price contexts
+ */
+import { GlobalTradingVariablesType } from "../../backend/tradingVariables/types";
+import { TradeContainer, UserPriceImpact } from "../types";
+import { GetLiquidationPriceContext } from "./types";
+/**
+ * @dev Builds a complete context for liquidation price calculations
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param tradeContainer Full trade container with trade, tradeInfo, fees data and liquidation params
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getLiquidationPrice
+ */
+export declare const buildLiquidationPriceContext: (globalTradingVariables: GlobalTradingVariablesType, tradeContainer: TradeContainer, additionalParams: {
+    currentBlock: number;
+    currentTimestamp: number;
+    currentPairPrice: number;
+    spreadP: number;
+    traderFeeMultiplier?: number;
+    additionalFeeCollateral?: number;
+    partialCloseMultiplier?: number;
+    beforeOpened?: boolean;
+    userPriceImpact?: UserPriceImpact;
+}) => GetLiquidationPriceContext;

package/lib/trade/liquidation/builder.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * @dev Liquidation price context builder module
+ * @dev Provides builder functions for creating liquidation price contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLiquidationPriceContext = void 0;
+const builder_1 = require("../fees/borrowing/builder");
+const builder_2 = require("../fees/borrowingV2/builder");
+const builder_3 = require("../fees/fundingFees/builder");
+const builder_4 = require("../fees/trading/builder");
+/**
+ * @dev Builds a complete context for liquidation price calculations
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param tradeContainer Full trade container with trade, tradeInfo, fees data and liquidation params
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getLiquidationPrice
+ */
+const buildLiquidationPriceContext = (globalTradingVariables, tradeContainer, additionalParams) => {
+    var _a;
+    const { trade, tradeInfo } = tradeContainer;
+    const collateralIndex = trade.collateralIndex || 1;
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!tradeContainer.liquidationParams) {
+        throw new Error("Liquidation params are required for liquidation price calculation");
+    }
+    return {
+        // Core shared context
+        core: {
+            currentBlock: additionalParams.currentBlock,
+            currentTimestamp: additionalParams.currentTimestamp,
+            collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+            contractsVersion: tradeInfo.contractsVersion,
+            spreadP: additionalParams.spreadP,
+        },
+        // Build sub-contexts using dedicated builders
+        borrowingV1: (0, builder_1.buildBorrowingV1Context)(globalTradingVariables, collateralIndex, additionalParams.currentBlock),
+        borrowingV2: (0, builder_2.buildBorrowingV2Context)(globalTradingVariables, collateralIndex, trade.pairIndex, additionalParams.currentTimestamp),
+        funding: (0, builder_3.buildFundingContext)(globalTradingVariables, collateralIndex, trade.pairIndex, additionalParams.currentTimestamp),
+        trading: Object.assign(Object.assign({}, (0, builder_4.buildTradingFeesContext)(globalTradingVariables, trade.pairIndex, additionalParams.traderFeeMultiplier)), { counterTradeSettings: globalTradingVariables.counterTradeSettings, userPriceImpact: additionalParams.userPriceImpact }),
+        // Trade-specific data
+        tradeData: {
+            tradeInfo,
+            tradeFeesData: tradeContainer.tradeFeesData,
+            liquidationParams: tradeContainer.liquidationParams,
+            initialAccFees: tradeContainer.initialAccFees,
+        },
+        // Additional parameters for liquidation calculation
+        liquidationSpecific: {
+            currentPairPrice: additionalParams.currentPairPrice,
+            additionalFeeCollateral: additionalParams.additionalFeeCollateral || 0,
+            partialCloseMultiplier: additionalParams.partialCloseMultiplier || 1,
+            beforeOpened: additionalParams.beforeOpened || false,
+            isCounterTrade: trade.isCounterTrade || false,
+            userPriceImpact: additionalParams.userPriceImpact,
+        },
+    };
+};
+exports.buildLiquidationPriceContext = buildLiquidationPriceContext;

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

@@ -1,31 +1,16 @@
 /**
  * @dev Main export file for liquidation module
  */
-import { Trade, Fee, BorrowingFee, LiquidationParams } from "..";
-import { GetLiquidationPriceContext, LiqPriceInput } from "./types";
+import { Trade, LiquidationParams } from "..";
+import { GetLiquidationPriceContext } from "./types";
 /**
- * @dev Wrapper function that mirrors the contract's getTradeLiquidationPrice signature
- * @dev This is the main entry point matching the contract interface
- * @param input Liquidation price input parameters
- * @param context Additional context for SDK calculations
- * @returns Liquidation price
- */
-export declare const getTradeLiquidationPrice: (input: LiqPriceInput, context: Omit<GetLiquidationPriceContext, "currentPairPrice" | "isCounterTrade" | "partialCloseMultiplier" | "additionalFeeCollateral" | "beforeOpened" | "liquidationParams"> & {
-    fee: Fee;
-}) => number;
-export declare const getLiquidationPrice: (trade: Trade, fee: Fee, initialAccFees: BorrowingFee.InitialAccFees, context: GetLiquidationPriceContext) => number;
-export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;
-/**
- * @dev Simplified wrapper for getTradeLiquidationPrice
- * @dev Mirrors the contract's simplified overload
+ * @dev Calculate liquidation price with structured context
  * @param trade The trade to calculate liquidation price for
- * @param additionalFeeCollateral Additional fees to consider
- * @param currentPairPrice Current pair price
- * @param context Context with all required data
+ * @param context Structured context with all required data
  * @returns Liquidation price
  */
-export declare const getTradeLiquidationPriceSimple: (trade: Trade, additionalFeeCollateral: number, currentPairPrice: number, context: Omit<GetLiquidationPriceContext, "currentPairPrice" | "additionalFeeCollateral"> & {
-    fee: Fee;
-}) => number;
+export declare const getLiquidationPrice: (trade: Trade, context: GetLiquidationPriceContext) => number;
+export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;
 export { convertLiquidationParams, convertLiquidationParamsArray, encodeLiquidationParams, } from "./converter";
 export * from "./types";
+export * from "./builder";

package/lib/trade/liquidation/index.js

@@ -17,98 +17,67 @@ 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.getTradeLiquidationPriceSimple = exports.getLiqPnlThresholdP = exports.getLiquidationPrice = exports.getTradeLiquidationPrice = void 0;
+exports.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
 const types_1 = require("../../contracts/types");
 const __1 = require("..");
 /**
- * @dev Wrapper function that mirrors the contract's getTradeLiquidationPrice signature
- * @dev This is the main entry point matching the contract interface
- * @param input Liquidation price input parameters
- * @param context Additional context for SDK calculations
+ * @dev Calculate liquidation price with structured context
+ * @param trade The trade to calculate liquidation price for
+ * @param context Structured context with all required data
  * @returns Liquidation price
  */
-const getTradeLiquidationPrice = (input, context) => {
-    // Create trade object from input
-    const trade = {
-        user: input.trader,
-        index: input.index,
-        pairIndex: input.pairIndex,
-        leverage: input.leverage,
-        long: input.long,
-        isOpen: true,
-        collateralIndex: input.collateralIndex,
-        tradeType: 0,
-        collateralAmount: input.collateral,
-        openPrice: input.openPrice,
-        sl: 0,
-        tp: 0,
-        isCounterTrade: input.isCounterTrade,
-    };
-    // Merge input params into context
-    const fullContext = Object.assign(Object.assign({}, context), { currentPairPrice: input.currentPairPrice, isCounterTrade: input.isCounterTrade, partialCloseMultiplier: input.partialCloseMultiplier, additionalFeeCollateral: input.additionalFeeCollateral, beforeOpened: input.beforeOpened, liquidationParams: input.liquidationParams });
-    // Call the existing implementation
-    return (0, exports.getLiquidationPrice)(trade, context.fee, context.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, fullContext);
-};
-exports.getTradeLiquidationPrice = getTradeLiquidationPrice;
-const getLiquidationPrice = (trade, fee, initialAccFees, context) => {
-    var _a, _b, _c, _d, _e, _f;
-    // Ensure initialAccFees is in context
-    if (!context.initialAccFees) {
-        context = Object.assign(Object.assign({}, context), { initialAccFees });
-    }
-    // 1. Calculate liquidation fees
-    const closingFee = (0, __1.getTotalTradeLiqFeesCollateral)(0, // collateralIndex not used in calculation
-    trade.user, trade.pairIndex, trade.collateralAmount, context);
-    // 2. Calculate holding fees and realized PnL
+const getLiquidationPrice = (trade, context) => {
+    var _a, _b;
+    // Extract parameters from structured context
+    const { currentPairPrice, additionalFeeCollateral = 0, partialCloseMultiplier = 1, beforeOpened = false, isCounterTrade = false, } = context.liquidationSpecific;
+    // 1. Calculate closing fees
+    const closingFee = (0, __1.getTotalTradeFeesCollateral)(trade.collateralIndex, "", // No fee tiers applied for liquidation calculation
+    trade.pairIndex, trade.collateralAmount * trade.leverage, isCounterTrade, {
+        fee: context.trading.fee,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        globalTradeFeeParams: context.trading.globalTradeFeeParams,
+        traderFeeMultiplier: 1,
+        counterTradeSettings: context.trading.counterTradeSettings,
+    });
+    // 2. Calculate holding fees and realized PnL for opened trades
     let holdingFeesTotal = 0;
     let totalRealizedPnlCollateral = 0;
-    if (!context.beforeOpened &&
-        context.tradeFeesData &&
-        context.currentPairPrice) {
-        // V10 data available - calculate full holding fees
-        // Create a minimal tradeInfo from context
-        const tradeInfo = {
-            contractsVersion: (_a = context.contractsVersion) !== null && _a !== void 0 ? _a : types_1.ContractsVersion.V10,
-            createdBlock: 0,
-            tpLastUpdatedBlock: 0,
-            slLastUpdatedBlock: 0,
-            maxSlippageP: 0,
-            lastOiUpdateTs: 0,
-            collateralPriceUsd: (_b = context.collateralPriceUsd) !== null && _b !== void 0 ? _b : 0,
-            lastPosIncreaseBlock: 0,
-        };
-        const holdingFees = (0, __1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, context.currentPairPrice, context);
+    if (!beforeOpened) {
+        // Calculate holding fees
+        const holdingFees = (0, __1.getTradePendingHoldingFeesCollateral)(trade, 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,
+        });
         holdingFeesTotal = holdingFees.totalFeeCollateral;
         // Calculate total realized PnL (realized PnL minus realized trading fees)
         totalRealizedPnlCollateral =
-            context.tradeFeesData.realizedPnlCollateral -
-                context.tradeFeesData.realizedTradingFeesCollateral;
-    }
-    else if (!context.beforeOpened) {
-        // Markets using v1 borrowing fees model
-        holdingFeesTotal = (0, __1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
+            context.tradeData.tradeFeesData.realizedPnlCollateral -
+                context.tradeData.tradeFeesData.realizedTradingFeesCollateral;
     }
     // 3. Apply unified formula for all trades
-    const partialCloseMultiplier = (_c = context.partialCloseMultiplier) !== null && _c !== void 0 ? _c : 1;
-    const additionalFeeCollateral = (_d = context.additionalFeeCollateral) !== null && _d !== void 0 ? _d : 0;
     const totalFeesCollateral = closingFee +
         (holdingFeesTotal - totalRealizedPnlCollateral) * partialCloseMultiplier +
         additionalFeeCollateral;
     // 4. Calculate liquidation threshold
-    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage);
+    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.tradeData.liquidationParams, trade.leverage);
     // 5. Calculate liquidation price distance
     const collateralLiqNegativePnl = trade.collateralAmount * liqThresholdP;
     let liqPriceDistance = (trade.openPrice * (collateralLiqNegativePnl - totalFeesCollateral)) /
         trade.collateralAmount /
         trade.leverage;
     // 6. Apply closing spread for v9.2+
-    if ((context === null || context === void 0 ? void 0 : context.contractsVersion) !== undefined &&
-        context.contractsVersion >= types_1.ContractsVersion.V9_2 &&
-        ((((_e = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _e === void 0 ? void 0 : _e.maxLiqSpreadP) !== undefined &&
-            context.liquidationParams.maxLiqSpreadP > 0) ||
-            (((_f = context === null || context === void 0 ? void 0 : context.userPriceImpact) === null || _f === void 0 ? void 0 : _f.fixedSpreadP) !== undefined &&
-                context.userPriceImpact.fixedSpreadP > 0))) {
-        const closingSpreadP = (0, __1.getSpreadP)(context.pairSpreadP, true, context.liquidationParams, context.userPriceImpact);
+    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 -= trade.openPrice * closingSpreadP;
     }
     // 7. Calculate final liquidation price
@@ -143,41 +112,6 @@ const getLiqPnlThresholdP = (liquidationParams, leverage) => {
             (liquidationParams.endLeverage - liquidationParams.startLeverage));
 };
 exports.getLiqPnlThresholdP = getLiqPnlThresholdP;
-/**
- * @dev Simplified wrapper for getTradeLiquidationPrice
- * @dev Mirrors the contract's simplified overload
- * @param trade The trade to calculate liquidation price for
- * @param additionalFeeCollateral Additional fees to consider
- * @param currentPairPrice Current pair price
- * @param context Context with all required data
- * @returns Liquidation price
- */
-const getTradeLiquidationPriceSimple = (trade, additionalFeeCollateral, currentPairPrice, context) => {
-    const input = {
-        collateralIndex: trade.collateralIndex,
-        trader: trade.user,
-        pairIndex: trade.pairIndex,
-        index: trade.index,
-        openPrice: trade.openPrice,
-        long: trade.long,
-        collateral: trade.collateralAmount,
-        leverage: trade.leverage,
-        additionalFeeCollateral,
-        liquidationParams: context.liquidationParams || {
-            maxLiqSpreadP: 0,
-            startLiqThresholdP: 0.9,
-            endLiqThresholdP: 0.9,
-            startLeverage: 0,
-            endLeverage: 0,
-        },
-        currentPairPrice,
-        isCounterTrade: trade.isCounterTrade || false,
-        partialCloseMultiplier: 1,
-        beforeOpened: false,
-    };
-    return (0, exports.getTradeLiquidationPrice)(input, context);
-};
-exports.getTradeLiquidationPriceSimple = getTradeLiquidationPriceSimple;
 // Converters
 var converter_1 = require("./converter");
 Object.defineProperty(exports, "convertLiquidationParams", { enumerable: true, get: function () { return converter_1.convertLiquidationParams; } });
@@ -185,3 +119,5 @@ Object.defineProperty(exports, "convertLiquidationParamsArray", { enumerable: tr
 Object.defineProperty(exports, "encodeLiquidationParams", { enumerable: true, get: function () { return converter_1.encodeLiquidationParams; } });
 // Types
 __exportStar(require("./types"), exports);
+// Builder
+__exportStar(require("./builder"), exports);

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

@@ -1,44 +1,42 @@
 import { GetBorrowingFeeContext, BorrowingFee } from "./../fees";
-import { GetLiquidationFeesContext } from "./../fees/trading";
-import { BorrowingFeeV2 } from "./../fees/borrowingV2";
-import { LiquidationParams, UserPriceImpact, TradeFeesData } from "./../types";
+import { LiquidationParams, UserPriceImpact, TradeFeesData, TradeInfo, CounterTradeSettings } from "./../types";
 import { ContractsVersion } from "../../contracts/types";
+import { GetPairBorrowingFeeV2Context } from "../fees/borrowingV2";
+import { GetPairFundingFeeContext } from "../fees/fundingFees";
+import { TradingFeesSubContext } from "../fees/trading/builder";
 /**
- * @dev Input parameters for getTradeLiquidationPrice
- * @dev Mirrors the contract's LiqPriceInput struct
+ * @dev Structured context for liquidation price calculations
+ * @dev Follows the same pattern as GetComprehensivePnlContext
  */
-export type LiqPriceInput = {
-    collateralIndex: number;
-    trader: string;
-    pairIndex: number;
-    index: number;
-    openPrice: number;
-    long: boolean;
-    collateral: number;
-    leverage: number;
-    additionalFeeCollateral: number;
-    liquidationParams: LiquidationParams;
-    currentPairPrice: number;
-    isCounterTrade: boolean;
-    partialCloseMultiplier: number;
-    beforeOpened: boolean;
-};
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & BorrowingFeeV2.GetBorrowingFeeV2Context & GetLiquidationFeesContext & {
-    liquidationParams: LiquidationParams | undefined;
-    pairSpreadP: number | undefined;
-    collateralPriceUsd: number | undefined;
-    contractsVersion: ContractsVersion | undefined;
-    userPriceImpact?: UserPriceImpact | undefined;
-    currentPairPrice?: number;
-    isCounterTrade?: boolean;
-    tradeFeesData?: TradeFeesData;
-    partialCloseMultiplier?: number;
-    additionalFeeCollateral?: number;
-    beforeOpened?: boolean;
-    initialAccFees?: BorrowingFee.InitialAccFees;
-    fundingParams?: Record<number, Record<number, any>>;
-    fundingData?: Record<number, Record<number, any>>;
-    pairOiAfterV10?: Record<number, Record<number, any>>;
-    netExposureToken?: Record<number, Record<number, number>>;
-    netExposureUsd?: Record<number, Record<number, number>>;
+export type GetLiquidationPriceContext = {
+    core: {
+        currentBlock: number;
+        currentTimestamp: number;
+        collateralPriceUsd: number;
+        contractsVersion: ContractsVersion;
+        spreadP: number;
+    };
+    borrowingV1?: GetBorrowingFeeContext;
+    borrowingV2?: GetPairBorrowingFeeV2Context;
+    funding?: GetPairFundingFeeContext;
+    trading: TradingFeesSubContext & {
+        userPriceImpact?: UserPriceImpact;
+        counterTradeSettings?: {
+            [pairIndex: number]: CounterTradeSettings;
+        };
+    };
+    tradeData: {
+        tradeInfo: TradeInfo;
+        tradeFeesData: TradeFeesData;
+        liquidationParams: LiquidationParams;
+        initialAccFees?: BorrowingFee.InitialAccFees;
+    };
+    liquidationSpecific: {
+        currentPairPrice: number;
+        additionalFeeCollateral: number;
+        partialCloseMultiplier: number;
+        beforeOpened: boolean;
+        isCounterTrade: boolean;
+        userPriceImpact?: UserPriceImpact;
+    };
 };

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

@@ -0,0 +1,16 @@
+import { TradeContainer } from "../types";
+import { GlobalTradingVariablesType } from "src/backend/tradingVariables/types";
+import { GetComprehensivePnlContext } from "./types";
+/**
+ * @dev Builds a complete context for comprehensive PnL calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param tradeContainer Full trade container with trade, tradeInfo, fees data and liquidation params
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getComprehensivePnl
+ */
+export declare const buildComprehensivePnlContext: (globalTradingVariables: GlobalTradingVariablesType, tradeContainer: TradeContainer, additionalParams: {
+    currentBlock: number;
+    currentTimestamp: number;
+    traderFeeMultiplier?: number;
+}) => GetComprehensivePnlContext;

package/lib/trade/pnl/builder.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComprehensivePnlContext = void 0;
+const builder_1 = require("../fees/borrowingV2/builder");
+const builder_2 = require("../fees/fundingFees/builder");
+const builder_3 = require("../fees/borrowing/builder");
+const builder_4 = require("../fees/trading/builder");
+/**
+ * @dev Builds a complete context for comprehensive PnL calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param tradeContainer Full trade container with trade, tradeInfo, fees data and liquidation params
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getComprehensivePnl
+ */
+const buildComprehensivePnlContext = (globalTradingVariables, tradeContainer, additionalParams) => {
+    var _a;
+    const { trade, tradeInfo } = tradeContainer;
+    const collateralIndex = trade.collateralIndex || 1;
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    return {
+        // Core shared context
+        core: {
+            currentBlock: additionalParams.currentBlock,
+            currentTimestamp: additionalParams.currentTimestamp,
+            collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+            contractsVersion: tradeInfo.contractsVersion,
+        },
+        // Build sub-contexts using dedicated builders
+        borrowingV1: (0, builder_3.buildBorrowingV1Context)(globalTradingVariables, collateralIndex, additionalParams.currentBlock),
+        borrowingV2: (0, builder_1.buildBorrowingV2Context)(globalTradingVariables, collateralIndex, trade.pairIndex, additionalParams.currentTimestamp),
+        funding: (0, builder_2.buildFundingContext)(globalTradingVariables, collateralIndex, trade.pairIndex, additionalParams.currentTimestamp),
+        trading: (0, builder_4.buildTradingFeesContext)(globalTradingVariables, trade.pairIndex, additionalParams.traderFeeMultiplier),
+        // Trade-specific data
+        tradeData: tradeContainer.tradeFeesData && tradeContainer.liquidationParams
+            ? {
+                tradeFeesData: tradeContainer.tradeFeesData,
+                liquidationParams: tradeContainer.liquidationParams,
+                initialAccFees: tradeContainer.initialAccFees,
+            }
+            : undefined,
+    };
+};
+exports.buildComprehensivePnlContext = buildComprehensivePnlContext;

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

@@ -2,10 +2,9 @@
  * @dev PnL calculation module
  * @dev Provides functions matching v10 contract implementations
  */
-import { Trade, TradeInfo, LiquidationParams } from "../types";
-import { ComprehensivePnlResult } from "./types";
-import { GetBorrowingFeeContext, BorrowingFee } from "../fees";
-import { GetTradeFeesContext } from "../fees/trading";
+import { Trade, TradeInfo, LiquidationParams, Fee, GlobalTradeFeeParams } from "../types";
+import { ComprehensivePnlResult, GetComprehensivePnlContext } from "./types";
+import { BorrowingFee } from "../fees/borrowing";
 import { ContractsVersion } from "../../contracts/types";
 /**
  * @dev Calculates PnL percentage for a position
@@ -26,31 +25,6 @@ export declare const getPnlPercent: (openPrice: number, currentPrice: number, lo
  * @returns Trade value after PnL and fees
  */
 export declare const getTradeValue: (collateral: number, pnlPercent: number, totalFees: number) => number;
-/**
- * @dev Context for comprehensive PnL calculations
- */
-export type GetComprehensivePnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
-    collateralPriceUsd: number;
-    contractsVersion: ContractsVersion;
-    currentTimestamp: number;
-    initialAccFees?: BorrowingFee.InitialAccFees;
-    borrowingProviderContext?: any;
-    fundingParams?: any;
-    fundingData?: any;
-    pairOiAfterV10?: any;
-    netExposureToken?: any;
-    netExposureUsd?: any;
-    tradeFeesData?: {
-        initialAccFundingFeeP: number;
-        initialAccBorrowingFeeP: number;
-        realizedPnlCollateral: number;
-        realizedTradingFeesCollateral: number;
-        manuallyRealizedNegativePnlCollateral?: number;
-        alreadyTransferredNegativePnlCollateral?: number;
-        virtualAvailableCollateralInDiamond?: number;
-    };
-    liquidationParams?: LiquidationParams;
-};
 /**
  * @dev Comprehensive PnL calculation including all fees
  * @param trade The trade to calculate PnL for
@@ -64,10 +38,16 @@ export declare const getComprehensivePnl: (trade: Trade, currentPrice: number, t
  * @dev Legacy getPnl function for backward compatibility
  * @deprecated Use getComprehensivePnl for new implementations
  */
-export type GetPnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
+export type GetPnlContext = {
+    currentBlock: number;
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
     collateralPriceUsd: number | undefined;
     contractsVersion: ContractsVersion | undefined;
     feeMultiplier: number | undefined;
+    fee: Fee;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    traderFeeMultiplier?: number;
 };
 /**
  * @dev Legacy PnL calculation function
@@ -82,5 +62,16 @@ export type GetPnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
  * @returns [pnlCollateral, pnlPercentage] or undefined if no price
  */
 export declare const getPnl: (price: number | undefined, trade: Trade, _tradeInfo: TradeInfo, initialAccFees: BorrowingFee.InitialAccFees, liquidationParams: LiquidationParams, useFees: boolean, context: GetPnlContext) => number[] | undefined;
+/**
+ * @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
+ */
+export declare const getPriceForTargetPnlPercentage: (targetPnlPercent: number, trade: Trade, tradeInfo: TradeInfo, context: GetComprehensivePnlContext, netPnl?: boolean) => number;
 export * from "./types";
 export * from "./converter";
+export * from "./builder";