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

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const pairContext_1 = require("../fundingFees/pairContext");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @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 Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, pairContext_1.getPairTradeFundingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            long: trade.long,
+            currentPairPrice,
+            initialAccFundingFeeP: tradeFeesData.initialAccFundingFeeP,
+        }, context.funding // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 && tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getPairTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getPairBorrowingFee)(positionSizeCollateral, trade.long, context.borrowingV1.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

package/lib/trade/fees/trading/holdingFeesStructured.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../../types";
+import { TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+import type { BorrowingV1SubContext, BorrowingV2SubContext, FundingFeesSubContext } from "../../pnl";
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: BorrowingV1SubContext;
+    borrowingV2?: BorrowingV2SubContext;
+    funding?: FundingFeesSubContext;
+};
+/**
+ * @dev Calculates total holding fees using structured context
+ * @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 Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateralStructured: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @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 Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    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 }) // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (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)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, undefined, // pairIndex not needed for pair-specific context
+        trade.long, context.borrowingV1.initialAccFees || {
+            accPairFee: 0,
+            accGroupFee: 0,
+            block: 0,
+        }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

package/lib/trade/fees/trading/index.d.ts

@@ -1,8 +1,13 @@
 /**
  * @dev Trading fee calculations for opening and closing positions
  */
-import { Fee, PairIndex } from "../../types";
-import { GetTradeFeesContext, GetLiquidationFeesContext, GetClosingFeeContext, TradeFeesBreakdown } from "./types";
+import { Fee, PairIndex, Trade, TradeInfo, TradeFeesData } from "../../types";
+import { GetBorrowingFeeContext } from "../borrowing";
+import * as BorrowingFee from "../borrowing/types";
+import { GetPairBorrowingFeeV2Context } from "../borrowingV2";
+import { GetPairFundingFeeContext } from "../fundingFees/pairContext";
+import { GetTradeFeesContext, GetLiquidationFeesContext, GetClosingFeeContext, TradeFeesBreakdown, TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
 /**
  * @dev Returns the total fee for a trade in collateral tokens
  * @dev Mirrors the contract's getTotalTradeFeesCollateral function
@@ -30,5 +35,28 @@ export declare const getTotalTradeLiqFeesCollateral: (collateralIndex: number, t
  * @deprecated Use getTotalTradeFeesCollateral instead
  */
 export declare const getClosingFee: (collateralAmount: number, leverage: number, pairIndex: PairIndex, pairFee: Fee | undefined, _collateralPriceUsd?: number | undefined, isCounterTrade?: boolean, trader?: string, context?: GetClosingFeeContext) => number;
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: GetBorrowingFeeContext;
+    borrowingV2?: GetPairBorrowingFeeV2Context;
+    funding?: GetPairFundingFeeContext;
+    initialAccFees?: BorrowingFee.InitialAccFees;
+};
+/**
+ * @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 Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateral: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;
 export * from "./types";
 export * from "./converter";
+export * from "./builder";

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

@@ -17,8 +17,12 @@ 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.getClosingFee = exports.getTotalTradeLiqFeesCollateral = exports.getTradeFeesCollateral = exports.getTotalTradeFeesCollateral = void 0;
+exports.getTradePendingHoldingFeesCollateral = exports.getClosingFee = exports.getTotalTradeLiqFeesCollateral = exports.getTradeFeesCollateral = exports.getTotalTradeFeesCollateral = void 0;
+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
  * @dev Mirrors the contract's getTotalTradeFeesCollateral function
@@ -99,6 +103,53 @@ isCounterTrade = false, trader, context) => {
     trader || "", pairIndex, positionSizeCollateral, isCounterTrade, context);
 };
 exports.getClosingFee = getClosingFee;
+/**
+ * @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 Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    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)
+    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,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateral = getTradePendingHoldingFeesCollateral;
 // Export types
 __exportStar(require("./types"), exports);
 __exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

package/lib/trade/fees/trading/types.d.ts

@@ -36,4 +36,13 @@ export type GetLiquidationFeesContext = {
  * @dev Legacy support
  */
 export type GetClosingFeeContext = GetTradeFeesContext;
+/**
+ * @dev Holding fees breakdown (funding + borrowing)
+ */
+export type TradeHoldingFees = {
+    fundingFeeCollateral: number;
+    borrowingFeeCollateral: number;
+    borrowingFeeCollateral_old: number;
+    totalFeeCollateral: number;
+};
 export type { GlobalTradeFeeParams };

package/lib/trade/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./fees";
-export * from "./pnl";
+export * from "./pnl/index";
 export * from "./spread";
 export * from "./liquidation";
 export * from "./types";
 export * from "./oiWindows";
 export * from "./priceImpact";
 export * from "./utils";
+export * from "./effectiveLeverage";
+export * from "./counterTrade";

package/lib/trade/index.js

@@ -15,10 +15,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./fees"), exports);
-__exportStar(require("./pnl"), exports);
+__exportStar(require("./pnl/index"), exports);
 __exportStar(require("./spread"), exports);
 __exportStar(require("./liquidation"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./oiWindows"), exports);
 __exportStar(require("./priceImpact"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./effectiveLeverage"), exports);
+__exportStar(require("./counterTrade"), 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/converter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @dev Converters for liquidation data between contract and SDK formats
+ */
+import { IPairsStorage } from "../../contracts/types/generated/GNSMultiCollatDiamond";
+import { LiquidationParams } from "../types";
+/**
+ * @dev Converts contract liquidation params to SDK format
+ * @param params Group liquidation params from contract
+ * @returns Normalized liquidation params
+ */
+export declare const convertLiquidationParams: (params: IPairsStorage.GroupLiquidationParamsStructOutput) => LiquidationParams;
+/**
+ * @dev Converts array of liquidation params from contract
+ * @param paramsArray Array of group liquidation params
+ * @returns Array of normalized liquidation params
+ */
+export declare const convertLiquidationParamsArray: (paramsArray: IPairsStorage.GroupLiquidationParamsStructOutput[]) => LiquidationParams[];
+/**
+ * @dev Converts liquidation params to contract format (for encoding)
+ * @param params SDK liquidation params
+ * @returns Contract-formatted liquidation params
+ */
+export declare const encodeLiquidationParams: (params: LiquidationParams) => IPairsStorage.GroupLiquidationParamsStruct;

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,16 @@
+/**
+ * @dev Main export file for liquidation module
+ */
+import { Trade, LiquidationParams } from "..";
+import { GetLiquidationPriceContext } from "./types";
+/**
+ * @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
+ */
+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

@@ -0,0 +1,123 @@
+"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.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
+const types_1 = require("../../contracts/types");
+const __1 = require("..");
+/**
+ * @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 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 (!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.tradeData.tradeFeesData.realizedPnlCollateral -
+                context.tradeData.tradeFeesData.realizedTradingFeesCollateral;
+    }
+    // 3. Apply unified formula for all trades
+    const totalFeesCollateral = closingFee +
+        (holdingFeesTotal - totalRealizedPnlCollateral) * partialCloseMultiplier +
+        additionalFeeCollateral;
+    // 4. Calculate liquidation threshold
+    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.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
+    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;
+// 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);
+// Builder
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,42 @@
+import { GetBorrowingFeeContext, BorrowingFee } from "./../fees";
+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 Structured context for liquidation price calculations
+ * @dev Follows the same pattern as GetComprehensivePnlContext
+ */
+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;
+    };
+};