@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc1

package/lib/trade/liquidation/index.js

@@ -0,0 +1,218 @@
+"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.getLiquidationPriceAfterPositionUpdate = 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;
+/**
+ * @dev Calculate liquidation price after a position size update
+ * @dev Mirrors the contract's IncreasePositionSizeUtils.sol and DecreasePositionSizeUtils.sol logic
+ * @param existingTrade The current trade before the update
+ * @param newCollateralAmount New collateral amount after the update
+ * @param newLeverage New leverage after the update
+ * @param isLeverageUpdate Whether this is a leverage update vs regular position change
+ * @param positionSizeCollateralDelta The absolute change in position size (in collateral terms)
+ * @param pnlToRealizeCollateral PnL to be realized (only relevant for leverage decrease)
+ * @param context Structured context with all required data (including additionalFeesCollateral for increases)
+ * @returns New liquidation price after the update
+ */
+const getLiquidationPriceAfterPositionUpdate = (existingTrade, newCollateralAmount, newLeverage, isLeverageUpdate, positionSizeCollateralDelta, pnlToRealizeCollateral, context) => {
+    var _a, _b;
+    const { currentPairPrice, isCounterTrade = false } = context.liquidationSpecific;
+    // 1. Calculate closing fees on the new position size
+    const closingFeeCollateral = (0, __1.getTotalTradeFeesCollateral)(existingTrade.collateralIndex, "", // No fee tiers applied for liquidation calculation
+    existingTrade.pairIndex, newCollateralAmount * newLeverage, isCounterTrade, {
+        fee: context.trading.fee,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        globalTradeFeeParams: context.trading.globalTradeFeeParams,
+        traderFeeMultiplier: 1,
+        counterTradeSettings: context.trading.counterTradeSettings,
+    });
+    // 2. Calculate holding fees on the EXISTING trade (full position)
+    const holdingFees = (0, __1.getTradePendingHoldingFeesCollateral)(existingTrade, 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,
+    });
+    // 3. Calculate total realized PnL
+    const totalRealizedPnlCollateral = context.tradeData.tradeFeesData.realizedPnlCollateral -
+        context.tradeData.tradeFeesData.realizedTradingFeesCollateral;
+    // 4. Determine if this is an increase or decrease
+    const existingPositionSizeCollateral = existingTrade.collateralAmount * existingTrade.leverage;
+    const newPositionSizeCollateral = newCollateralAmount * newLeverage;
+    const isIncrease = newPositionSizeCollateral > existingPositionSizeCollateral;
+    // 5. Calculate additional fee and partial close multiplier based on update type
+    let additionalFeeCollateral;
+    let partialCloseMultiplier;
+    if (isIncrease) {
+        // For position increases: use additional fees from context (e.g., opening fees)
+        additionalFeeCollateral =
+            context.liquidationSpecific.additionalFeeCollateral || 0;
+        partialCloseMultiplier = 1; // Set to 1
+    }
+    else if (isLeverageUpdate) {
+        // For leverage decreases: additional fee includes closing fee minus PnL to realize
+        additionalFeeCollateral = closingFeeCollateral - pnlToRealizeCollateral;
+        partialCloseMultiplier = 1; // Full multiplier for leverage updates
+    }
+    else {
+        // For regular position decreases: no additional fee, scaled multiplier
+        additionalFeeCollateral = 0;
+        partialCloseMultiplier =
+            (existingPositionSizeCollateral - positionSizeCollateralDelta) /
+                existingPositionSizeCollateral;
+    }
+    // 6. Calculate total fees
+    const totalFeesCollateral = closingFeeCollateral +
+        (holdingFees.totalFeeCollateral - totalRealizedPnlCollateral) *
+            partialCloseMultiplier +
+        additionalFeeCollateral;
+    // 7. Calculate liquidation threshold
+    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.tradeData.liquidationParams, newLeverage);
+    // 8. Calculate liquidation price distance
+    const collateralLiqNegativePnl = newCollateralAmount * liqThresholdP;
+    // For increases, we need to use the new weighted average open price
+    // For decreases, we use the existing open price
+    const openPriceToUse = isIncrease
+        ? context.liquidationSpecific.newOpenPrice || existingTrade.openPrice
+        : existingTrade.openPrice;
+    let liqPriceDistance = (openPriceToUse * (collateralLiqNegativePnl - totalFeesCollateral)) /
+        newCollateralAmount /
+        newLeverage;
+    // 9. 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 -= openPriceToUse * closingSpreadP;
+    }
+    // 10. Calculate final liquidation price
+    return existingTrade.long
+        ? Math.max(openPriceToUse - liqPriceDistance, 0)
+        : Math.max(openPriceToUse + liqPriceDistance, 0);
+};
+exports.getLiquidationPriceAfterPositionUpdate = getLiquidationPriceAfterPositionUpdate;
+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,43 @@
+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;
+        newOpenPrice?: number;
+    };
+};

package/lib/trade/liquidation/types.js

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

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

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

package/lib/trade/pnl/builder.js

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

package/lib/trade/pnl/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,89 @@
+/**
+ * @dev PnL calculation module
+ * @dev Provides functions matching v10 contract implementations
+ */
+import { Trade, TradeInfo, LiquidationParams, Fee, GlobalTradeFeeParams, TradeFeesData } from "../types";
+import { ComprehensivePnlResult, GetComprehensivePnlContext } from "./types";
+import { BorrowingFee } from "../fees/borrowing";
+import { ContractsVersion } from "../../contracts/types";
+/**
+ * @dev Gets trade realized PnL components from TradeFeesData
+ * @dev Mirrors contract's getTradeRealizedPnlCollateral function
+ * @param tradeFeesData Trade fees data containing realized components
+ * @returns Tuple of [realizedPnlCollateral, realizedTradingFeesCollateral, totalRealizedPnlCollateral]
+ */
+export declare const getTradeRealizedPnlCollateral: (tradeFeesData: TradeFeesData) => {
+    realizedPnlCollateral: number;
+    realizedTradingFeesCollateral: number;
+    totalRealizedPnlCollateral: number;
+};
+/**
+ * @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 Comprehensive PnL calculation including all fees
+ * @param trade The trade to calculate PnL for
+ * @param marketPrice Current market price (without price impact)
+ * @param executionPrice Price after all impacts (spread, skew, volume)
+ * @param tradeInfo Trade info with version and timestamps
+ * @param context Context with all fee parameters
+ * @returns Detailed PnL breakdown
+ */
+export declare const getComprehensivePnl: (trade: Trade, marketPrice: number, executionPrice: number, tradeInfo: TradeInfo, context: GetComprehensivePnlContext) => ComprehensivePnlResult;
+/**
+ * @dev Legacy getPnl function for backward compatibility
+ * @deprecated Use getComprehensivePnl for new implementations
+ */
+export type GetPnlContext = {
+    currentBlock: number;
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+    collateralPriceUsd: number | undefined;
+    contractsVersion: ContractsVersion | undefined;
+    feeMultiplier: number | undefined;
+    fee: Fee;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Legacy PnL calculation function
+ * @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;
+/**
+ * @dev Calculates the price needed to achieve a target PnL percentage
+ * @param targetPnlPercent The target PnL percentage (e.g., 50 for 50% profit, -25 for 25% loss)
+ * @param trade The trade to calculate for
+ * @param tradeInfo Trade info with timestamps
+ * @param context Context with fee calculation parameters
+ * @param netPnl Whether to include closing fees in the calculation
+ * @returns The price that would result in the target PnL percentage
+ */
+export declare const getPriceForTargetPnlPercentage: (targetPnlPercent: number, trade: Trade, tradeInfo: TradeInfo, context: GetComprehensivePnlContext, netPnl?: boolean) => number;
+export * from "./types";
+export * from "./converter";
+export * from "./builder";