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

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/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;

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

@@ -0,0 +1,86 @@
+/**
+ * @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 { ContractsVersion } from "../../contracts/types";
+/**
+ * @dev Calculates PnL percentage for a position
+ * @dev Mirrors contract's getPnlPercent function
+ * @param openPrice Trade open price
+ * @param currentPrice Current market price
+ * @param long Whether position is long
+ * @param leverage Position leverage
+ * @returns PnL percentage (e.g., 10 = 10% profit, -50 = 50% loss)
+ */
+export declare const getPnlPercent: (openPrice: number, currentPrice: number, long: boolean, leverage: number) => number;
+/**
+ * @dev Calculates trade value from collateral and PnL
+ * @dev Mirrors contract's getTradeValuePure function
+ * @param collateral Trade collateral amount
+ * @param pnlPercent PnL percentage
+ * @param totalFees Total fees to deduct
+ * @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
+ * @param currentPrice Current market price
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @returns Detailed PnL breakdown
+ */
+export declare const getComprehensivePnl: (trade: Trade, currentPrice: number, tradeInfo: TradeInfo, context: GetComprehensivePnlContext) => ComprehensivePnlResult;
+/**
+ * @dev Legacy getPnl function for backward compatibility
+ * @deprecated Use getComprehensivePnl for new implementations
+ */
+export type GetPnlContext = GetBorrowingFeeContext & GetTradeFeesContext & {
+    collateralPriceUsd: number | undefined;
+    contractsVersion: ContractsVersion | undefined;
+    feeMultiplier: number | undefined;
+};
+/**
+ * @dev Legacy PnL calculation function
+ * @deprecated Use getComprehensivePnl for more comprehensive calculations
+ * @param price Current price
+ * @param trade Trade object
+ * @param tradeInfo Trade info (not used in legacy implementation)
+ * @param initialAccFees Initial accumulated fees
+ * @param liquidationParams Liquidation parameters
+ * @param useFees Whether to include fees
+ * @param context Context with fee calculation parameters
+ * @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;
+export * from "./types";
+export * from "./converter";

package/lib/trade/pnl/index.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * @dev PnL calculation module
+ * @dev Provides functions matching v10 contract implementations
+ */
+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.getPnl = exports.getComprehensivePnl = exports.getTradeValue = exports.getPnlPercent = void 0;
+const fees_1 = require("../fees");
+const borrowingV2_1 = require("../fees/borrowingV2");
+const fundingFees_1 = require("../fees/fundingFees");
+const trading_1 = require("../fees/trading");
+const liquidation_1 = require("../liquidation");
+const types_1 = require("../../contracts/types");
+/**
+ * @dev Calculates PnL percentage for a position
+ * @dev Mirrors contract's getPnlPercent function
+ * @param openPrice Trade open price
+ * @param currentPrice Current market price
+ * @param long Whether position is long
+ * @param leverage Position leverage
+ * @returns PnL percentage (e.g., 10 = 10% profit, -50 = 50% loss)
+ */
+const getPnlPercent = (openPrice, currentPrice, long, leverage) => {
+    if (openPrice === 0)
+        return -100;
+    const priceDiff = long ? currentPrice - openPrice : openPrice - currentPrice;
+    const pnlPercent = (priceDiff / openPrice) * 100 * leverage;
+    // Cap at -100% loss
+    return Math.max(pnlPercent, -100);
+};
+exports.getPnlPercent = getPnlPercent;
+/**
+ * @dev Calculates trade value from collateral and PnL
+ * @dev Mirrors contract's getTradeValuePure function
+ * @param collateral Trade collateral amount
+ * @param pnlPercent PnL percentage
+ * @param totalFees Total fees to deduct
+ * @returns Trade value after PnL and fees
+ */
+const getTradeValue = (collateral, pnlPercent, totalFees) => {
+    const pnlCollateral = collateral * (pnlPercent / 100);
+    const value = collateral + pnlCollateral - totalFees;
+    return Math.max(0, value);
+};
+exports.getTradeValue = getTradeValue;
+/**
+ * @dev Comprehensive PnL calculation including all fees
+ * @param trade The trade to calculate PnL for
+ * @param currentPrice Current market price
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @returns Detailed PnL breakdown
+ */
+const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
+    // Calculate base PnL percentage
+    let pnlPercent = (0, exports.getPnlPercent)(trade.openPrice, currentPrice, trade.long, trade.leverage);
+    // Calculate position size
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Initialize fees
+    let borrowingFeeV1 = 0;
+    let borrowingFeeV2 = 0;
+    let fundingFee = 0;
+    // Calculate holding fees based on version
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.tradeFeesData) {
+        // V10: Use aggregated holding fees function
+        const holdingFees = (0, trading_1.getTradePendingHoldingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, // Cast to handle partial type
+        currentPrice, context);
+        fundingFee = holdingFees.fundingFeeCollateral;
+        borrowingFeeV2 = holdingFees.borrowingFeeCollateral;
+        borrowingFeeV1 = holdingFees.borrowingFeeCollateral_old;
+    }
+    else {
+        // Pre-v10: Calculate fees individually
+        // V1 borrowing fees (still used by some markets)
+        if (context.initialAccFees) {
+            borrowingFeeV1 = (0, fees_1.getBorrowingFee)(positionSizeCollateral, trade.pairIndex, trade.long, context.initialAccFees, context);
+        }
+        // V2 borrowing fees
+        if (context.tradeFeesData && context.borrowingProviderContext) {
+            borrowingFeeV2 = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+                positionSizeCollateral,
+                openPrice: trade.openPrice,
+                collateralIndex: trade.collateralIndex,
+                pairIndex: trade.pairIndex,
+                currentPairPrice: currentPrice,
+                initialAccBorrowingFeeP: context.tradeFeesData.initialAccBorrowingFeeP,
+                currentTimestamp: context.currentTimestamp,
+            }, context.borrowingProviderContext);
+        }
+        // Funding fees (v10+)
+        if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+            context.tradeFeesData) {
+            fundingFee = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, context.tradeFeesData, // Cast to handle partial type
+            currentPrice, context);
+        }
+    }
+    // Calculate closing fees
+    const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(trade.collateralIndex, trade.user, trade.pairIndex, positionSizeCollateral, trade.isCounterTrade || false, context);
+    // Total fees
+    const totalFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee + closingFee;
+    // Check liquidation
+    const liquidationThreshold = context.liquidationParams
+        ? (0, liquidation_1.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage) * -100
+        : -90; // Default 90% loss
+    const isLiquidated = pnlPercent <= liquidationThreshold;
+    // If liquidated, set PnL to -100%
+    if (isLiquidated) {
+        pnlPercent = -100;
+    }
+    // Calculate final trade value
+    const tradeValue = (0, exports.getTradeValue)(trade.collateralAmount, pnlPercent, totalFees);
+    // Calculate PnL in collateral
+    const pnlCollateral = trade.collateralAmount * (pnlPercent / 100);
+    // Calculate leveraged position size
+    const leveragedPositionSize = trade.collateralAmount * trade.leverage;
+    // Calculate net PnL after fees
+    const netPnlAfterFees = pnlCollateral - totalFees;
+    return {
+        // Core PnL values
+        pnlPercent,
+        pnlCollateral,
+        tradeValue,
+        // Fee breakdown
+        fees: {
+            borrowingV1: borrowingFeeV1,
+            borrowingV2: borrowingFeeV2,
+            funding: fundingFee,
+            closing: closingFee,
+            total: totalFees,
+        },
+        // Status flags
+        isLiquidated,
+        isProfitable: pnlPercent > 0,
+        // Additional info
+        leveragedPositionSize,
+        netPnlAfterFees,
+    };
+};
+exports.getComprehensivePnl = getComprehensivePnl;
+/**
+ * @dev Legacy PnL calculation function
+ * @deprecated Use getComprehensivePnl for more comprehensive calculations
+ * @param price Current price
+ * @param trade Trade object
+ * @param tradeInfo Trade info (not used in legacy implementation)
+ * @param initialAccFees Initial accumulated fees
+ * @param liquidationParams Liquidation parameters
+ * @param useFees Whether to include fees
+ * @param context Context with fee calculation parameters
+ * @returns [pnlCollateral, pnlPercentage] or undefined if no price
+ */
+const getPnl = (price, trade, _tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
+    var _a;
+    if (!price) {
+        return;
+    }
+    const posCollat = trade.collateralAmount;
+    const { openPrice, leverage } = trade;
+    let pnlCollat = trade.long
+        ? ((price - openPrice) / openPrice) * leverage * posCollat
+        : ((openPrice - price) / openPrice) * leverage * posCollat;
+    if (useFees) {
+        pnlCollat -= (0, fees_1.getBorrowingFee)(posCollat * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
+    }
+    let pnlPercentage = (pnlCollat / posCollat) * 100;
+    // Can be liquidated
+    if (pnlPercentage <=
+        (0, liquidation_1.getLiqPnlThresholdP)(liquidationParams, leverage) * -100) {
+        pnlPercentage = -100;
+    }
+    else {
+        // Calculate closing fee using the same function as opening fees
+        const positionSizeCollateral = posCollat * trade.leverage;
+        const closingFee = (0, trading_1.getTotalTradeFeesCollateral)(0, // collateralIndex not used
+        trade.user, trade.pairIndex, positionSizeCollateral, (_a = trade.isCounterTrade) !== null && _a !== void 0 ? _a : false, context);
+        pnlCollat -= closingFee;
+        pnlPercentage = (pnlCollat / posCollat) * 100;
+    }
+    pnlPercentage = pnlPercentage < -100 ? -100 : pnlPercentage;
+    pnlCollat = (posCollat * pnlPercentage) / 100;
+    return [pnlCollat, pnlPercentage];
+};
+exports.getPnl = getPnl;
+// Re-export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./converter"), exports);