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

package/lib/trade/liquidation/converter.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @dev Converters for liquidation data between contract and SDK formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = void 0;
+/**
+ * @dev Converts contract liquidation params to SDK format
+ * @param params Group liquidation params from contract
+ * @returns Normalized liquidation params
+ */
+const convertLiquidationParams = (params) => {
+    const ONCHAIN_LIQ_THRESHOLD = 0.9;
+    return {
+        maxLiqSpreadP: Number(params.maxLiqSpreadP) / 1e10 / 100,
+        startLiqThresholdP: Number(params.startLiqThresholdP) / 1e10 / 100 || ONCHAIN_LIQ_THRESHOLD,
+        endLiqThresholdP: Number(params.endLiqThresholdP) / 1e10 / 100 || ONCHAIN_LIQ_THRESHOLD,
+        startLeverage: Number(params.startLeverage) / 1e3,
+        endLeverage: Number(params.endLeverage) / 1e3, // 1e3 → float
+    };
+};
+exports.convertLiquidationParams = convertLiquidationParams;
+/**
+ * @dev Converts array of liquidation params from contract
+ * @param paramsArray Array of group liquidation params
+ * @returns Array of normalized liquidation params
+ */
+const convertLiquidationParamsArray = (paramsArray) => {
+    return paramsArray.map(exports.convertLiquidationParams);
+};
+exports.convertLiquidationParamsArray = convertLiquidationParamsArray;
+/**
+ * @dev Converts liquidation params to contract format (for encoding)
+ * @param params SDK liquidation params
+ * @returns Contract-formatted liquidation params
+ */
+const encodeLiquidationParams = (params) => {
+    return {
+        maxLiqSpreadP: Math.round(params.maxLiqSpreadP * 100 * 1e10),
+        startLiqThresholdP: Math.round(params.startLiqThresholdP * 100 * 1e10),
+        endLiqThresholdP: Math.round(params.endLiqThresholdP * 100 * 1e10),
+        startLeverage: Math.round(params.startLeverage * 1e3),
+        endLeverage: Math.round(params.endLeverage * 1e3), // float → 1e3
+    };
+};
+exports.encodeLiquidationParams = encodeLiquidationParams;

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

@@ -0,0 +1,31 @@
+/**
+ * @dev Main export file for liquidation module
+ */
+import { Trade, Fee, BorrowingFee, LiquidationParams } from "..";
+import { GetLiquidationPriceContext, LiqPriceInput } 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
+ * @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
+ */
+export declare const getTradeLiquidationPriceSimple: (trade: Trade, additionalFeeCollateral: number, currentPairPrice: number, context: Omit<GetLiquidationPriceContext, "currentPairPrice" | "additionalFeeCollateral"> & {
+    fee: Fee;
+}) => number;
+export { convertLiquidationParams, convertLiquidationParamsArray, encodeLiquidationParams, } from "./converter";
+export * from "./types";

package/lib/trade/liquidation/index.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * @dev Main export file for liquidation module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getTradeLiquidationPriceSimple = exports.getLiqPnlThresholdP = exports.getLiquidationPrice = exports.getTradeLiquidationPrice = 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
+ * @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
+    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);
+        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);
+    }
+    // 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);
+    // 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);
+        liqPriceDistance -= trade.openPrice * closingSpreadP;
+    }
+    // 7. Calculate final liquidation price
+    return trade.long
+        ? Math.max(trade.openPrice - liqPriceDistance, 0)
+        : Math.max(trade.openPrice + liqPriceDistance, 0);
+};
+exports.getLiquidationPrice = getLiquidationPrice;
+const getLiqPnlThresholdP = (liquidationParams, leverage) => {
+    if (liquidationParams === undefined ||
+        leverage === undefined ||
+        liquidationParams.maxLiqSpreadP === 0 ||
+        liquidationParams.startLiqThresholdP === 0 ||
+        liquidationParams.endLiqThresholdP === 0 ||
+        liquidationParams.startLeverage === 0 ||
+        liquidationParams.endLeverage === 0) {
+        return 0.9;
+    }
+    if (leverage < liquidationParams.startLeverage) {
+        return liquidationParams.startLiqThresholdP;
+    }
+    if (leverage > liquidationParams.endLeverage) {
+        return liquidationParams.endLiqThresholdP;
+    }
+    if (liquidationParams.startLiqThresholdP === liquidationParams.endLiqThresholdP) {
+        return liquidationParams.endLiqThresholdP;
+    }
+    return (liquidationParams.startLiqThresholdP -
+        ((leverage - liquidationParams.startLeverage) *
+            (liquidationParams.startLiqThresholdP -
+                liquidationParams.endLiqThresholdP)) /
+            (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; } });
+Object.defineProperty(exports, "convertLiquidationParamsArray", { enumerable: true, get: function () { return converter_1.convertLiquidationParamsArray; } });
+Object.defineProperty(exports, "encodeLiquidationParams", { enumerable: true, get: function () { return converter_1.encodeLiquidationParams; } });
+// Types
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,44 @@
+import { GetBorrowingFeeContext, BorrowingFee } from "./../fees";
+import { GetLiquidationFeesContext } from "./../fees/trading";
+import { BorrowingFeeV2 } from "./../fees/borrowingV2";
+import { LiquidationParams, UserPriceImpact, TradeFeesData } from "./../types";
+import { ContractsVersion } from "../../contracts/types";
+/**
+ * @dev Input parameters for getTradeLiquidationPrice
+ * @dev Mirrors the contract's LiqPriceInput struct
+ */
+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>>;
+};

package/lib/trade/liquidation/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/trade/liquidation.d.ts

@@ -1,42 +1,12 @@
 import { GetBorrowingFeeContext, BorrowingFee } from "./fees";
-import { GetLiquidationFeesContext } from "./fees/trading";
-import { BorrowingFeeV2 } from "./fees/borrowingV2";
-import { Fee, LiquidationParams, Trade, TradeInfo, UserPriceImpact, TradeFeesData } from "./types";
+import { Fee, LiquidationParams, Trade, UserPriceImpact } from "./types";
 import { ContractsVersion } from "../contracts/types";
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & BorrowingFeeV2.GetBorrowingFeeV2Context & GetLiquidationFeesContext & {
+export type GetLiquidationPriceContext = GetBorrowingFeeContext & {
     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 TradeHoldingFees = {
-    fundingFeeCollateral: number;
-    borrowingFeeCollateral: number;
-    borrowingFeeCollateral_old: number;
-    totalFeeCollateral: number;
-};
-/**
- * @dev Calculates total holding fees for a trade (funding + borrowing fees)
- * @param trade The trade to calculate fees for
- * @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
- * @returns Object containing all holding fee components
- */
-export declare const getTradePendingHoldingFeesCollateral: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetLiquidationPriceContext) => TradeHoldingFees;
 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;

package/lib/trade/liquidation.js

@@ -1,112 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLiqPnlThresholdP = exports.getLiquidationPrice = exports.getTradePendingHoldingFeesCollateral = void 0;
+exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
 const fees_1 = require("./fees");
-const trading_1 = require("./fees/trading");
-const borrowingV2_1 = require("./fees/borrowingV2");
 const spread_1 = require("./spread");
 const types_1 = require("../contracts/types");
-/**
- * @dev Calculates total holding fees for a trade (funding + borrowing fees)
- * @param trade The trade to calculate fees for
- * @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
- * @returns Object containing all holding fee components
- */
-const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
-    var _a;
-    // Calculate funding fees (v10+ only)
-    const fundingFeeCollateral = ((_a = context.contractsVersion) !== null && _a !== void 0 ? _a : tradeInfo.contractsVersion) >=
-        types_1.ContractsVersion.V10
-        ? (0, fees_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);
-    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
-    const borrowingFeeCollateral_old = (0, fees_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);
-    return {
-        fundingFeeCollateral,
-        borrowingFeeCollateral,
-        borrowingFeeCollateral_old,
-        totalFeeCollateral: fundingFeeCollateral +
-            borrowingFeeCollateral +
-            borrowingFeeCollateral_old,
-    };
-};
-exports.getTradePendingHoldingFeesCollateral = getTradePendingHoldingFeesCollateral;
 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, trading_1.getTotalTradeLiqFeesCollateral)(0, // collateralIndex not used in calculation
-    trade.user, trade.pairIndex, trade.collateralAmount, context);
-    // 2. Calculate holding fees and realized PnL
-    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, exports.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, context.currentPairPrice, context);
-        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, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
-    }
-    // 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
+    var _a, _b;
+    const closingFee = (0, fees_1.getClosingFee)(trade.collateralAmount, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd);
+    const borrowingFee = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
     const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage);
-    // 5. Calculate liquidation price distance
-    const collateralLiqNegativePnl = trade.collateralAmount * liqThresholdP;
-    let liqPriceDistance = (trade.openPrice * (collateralLiqNegativePnl - totalFeesCollateral)) /
+    let liqPriceDistance = (trade.openPrice *
+        (trade.collateralAmount * liqThresholdP - (borrowingFee + closingFee))) /
         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 &&
+        ((((_a = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _a === void 0 ? void 0 : _a.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 &&
+            (((_b = context === null || context === void 0 ? void 0 : context.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !== undefined &&
                 context.userPriceImpact.fixedSpreadP > 0))) {
         const closingSpreadP = (0, spread_1.getSpreadP)(context.pairSpreadP, true, context.liquidationParams, context.userPriceImpact);
         liqPriceDistance -= trade.openPrice * closingSpreadP;
     }
-    // 7. Calculate final liquidation price
     return trade.long
         ? Math.max(trade.openPrice - liqPriceDistance, 0)
         : Math.max(trade.openPrice + liqPriceDistance, 0);

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

@@ -0,0 +1,47 @@
+/**
+ * @dev Converters for PnL data between contract and SDK formats
+ */
+/**
+ * @dev Convert PnL percentage from contract precision to SDK format
+ * @param pnlPercentContract PnL percentage with 1e10 precision
+ * @returns PnL percentage as regular number (e.g., 10 = 10%)
+ */
+export declare const convertPnlPercent: (pnlPercentContract: bigint | number) => number;
+/**
+ * @dev Convert PnL percentage from SDK format to contract precision
+ * @param pnlPercent PnL percentage as regular number
+ * @returns PnL percentage with 1e10 precision
+ */
+export declare const encodePnlPercent: (pnlPercent: number) => bigint;
+/**
+ * @dev Convert collateral amount considering precision
+ * @param amount Amount in contract format
+ * @param collateralDecimals Collateral token decimals (6 or 18)
+ * @returns Amount as SDK float
+ */
+export declare const convertCollateralAmount: (amount: bigint | number, collateralDecimals: number) => number;
+/**
+ * @dev Convert price from contract format to SDK format
+ * @param price Price with 1e10 precision
+ * @returns Price as SDK float
+ */
+export declare const convertPrice: (price: bigint | number) => number;
+/**
+ * @dev Convert leverage from contract format to SDK format
+ * @param leverage Leverage with 1e3 precision
+ * @returns Leverage as SDK float (e.g., 10 = 10x)
+ */
+export declare const convertLeverage: (leverage: bigint | number) => number;
+/**
+ * @dev Batch convert PnL results from contract format
+ * @param results Array of PnL results from contract
+ * @param collateralDecimals Collateral token decimals
+ * @returns Array of converted PnL results
+ */
+export declare const convertPnlResults: (results: Array<{
+    pnlCollateral: bigint;
+    pnlPercent: bigint;
+}>, collateralDecimals: number) => Array<{
+    pnlCollateral: number;
+    pnlPercent: number;
+}>;

package/lib/trade/pnl/converter.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * @dev Converters for PnL data between contract and SDK formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPnlResults = exports.convertLeverage = exports.convertPrice = exports.convertCollateralAmount = exports.encodePnlPercent = exports.convertPnlPercent = void 0;
+/**
+ * @dev Convert PnL percentage from contract precision to SDK format
+ * @param pnlPercentContract PnL percentage with 1e10 precision
+ * @returns PnL percentage as regular number (e.g., 10 = 10%)
+ */
+const convertPnlPercent = (pnlPercentContract) => {
+    const value = typeof pnlPercentContract === "bigint"
+        ? Number(pnlPercentContract)
+        : pnlPercentContract;
+    // Contract uses 1e10 precision for percentages
+    return value / 1e10;
+};
+exports.convertPnlPercent = convertPnlPercent;
+/**
+ * @dev Convert PnL percentage from SDK format to contract precision
+ * @param pnlPercent PnL percentage as regular number
+ * @returns PnL percentage with 1e10 precision
+ */
+const encodePnlPercent = (pnlPercent) => {
+    return BigInt(Math.round(pnlPercent * 1e10));
+};
+exports.encodePnlPercent = encodePnlPercent;
+/**
+ * @dev Convert collateral amount considering precision
+ * @param amount Amount in contract format
+ * @param collateralDecimals Collateral token decimals (6 or 18)
+ * @returns Amount as SDK float
+ */
+const convertCollateralAmount = (amount, collateralDecimals) => {
+    const value = typeof amount === "bigint" ? Number(amount) : amount;
+    return value / Math.pow(10, collateralDecimals);
+};
+exports.convertCollateralAmount = convertCollateralAmount;
+/**
+ * @dev Convert price from contract format to SDK format
+ * @param price Price with 1e10 precision
+ * @returns Price as SDK float
+ */
+const convertPrice = (price) => {
+    const value = typeof price === "bigint" ? Number(price) : price;
+    return value / 1e10;
+};
+exports.convertPrice = convertPrice;
+/**
+ * @dev Convert leverage from contract format to SDK format
+ * @param leverage Leverage with 1e3 precision
+ * @returns Leverage as SDK float (e.g., 10 = 10x)
+ */
+const convertLeverage = (leverage) => {
+    const value = typeof leverage === "bigint" ? Number(leverage) : leverage;
+    return value / 1e3;
+};
+exports.convertLeverage = convertLeverage;
+/**
+ * @dev Batch convert PnL results from contract format
+ * @param results Array of PnL results from contract
+ * @param collateralDecimals Collateral token decimals
+ * @returns Array of converted PnL results
+ */
+const convertPnlResults = (results, collateralDecimals) => {
+    return results.map(result => ({
+        pnlCollateral: (0, exports.convertCollateralAmount)(result.pnlCollateral, collateralDecimals),
+        pnlPercent: (0, exports.convertPnlPercent)(result.pnlPercent),
+    }));
+};
+exports.convertPnlResults = convertPnlResults;