@gainsnetwork/sdk 0.0.0-me-rc1

package/lib/trade/priceImpact/cumulVol/index.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * @dev Cumulative volume price impact calculations
+ * @dev Mirrors contract's getTradeCumulVolPriceImpactP functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCumulVolContext = exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = exports.getSpreadWithPriceImpactP = exports.getCumulVolPriceImpact = exports.getSpreadWithCumulVolPriceImpactP = exports.getSpreadP = exports.getFixedSpreadP = exports.getTradeCumulVolPriceImpactP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = void 0;
+const oiWindows_1 = require("../../oiWindows");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../contracts/types");
+/**
+ * @dev Gets the protection close factor with user multiplier
+ * @param context Cumulative volume context
+ * @returns Protection close factor (1 = 100%)
+ */
+const getProtectionCloseFactor = (context) => {
+    const protectionCloseFactor = context === undefined ||
+        context.contractsVersion === types_1.ContractsVersion.BEFORE_V9_2 ||
+        context.isOpen === undefined ||
+        context.isPnlPositive === undefined ||
+        context.protectionCloseFactor === undefined ||
+        (0, exports.isProtectionCloseFactorActive)(context) !== true
+        ? constants_1.DEFAULT_PROTECTION_CLOSE_FACTOR
+        : context.protectionCloseFactor;
+    const protectionCloseFactorMultiplier = context?.userPriceImpact?.cumulVolPriceImpactMultiplier !== undefined &&
+        context.userPriceImpact.cumulVolPriceImpactMultiplier > 0
+        ? context.userPriceImpact.cumulVolPriceImpactMultiplier
+        : 1;
+    return protectionCloseFactor * protectionCloseFactorMultiplier;
+};
+exports.getProtectionCloseFactor = getProtectionCloseFactor;
+/**
+ * @dev Checks if protection close factor is active
+ * @param context Cumulative volume context
+ * @returns True if protection close factor should be applied
+ */
+const isProtectionCloseFactorActive = (context) => {
+    if (context === undefined ||
+        context.currentBlock === undefined ||
+        context.createdBlock === undefined ||
+        context.protectionCloseFactorBlocks === undefined ||
+        context.protectionCloseFactor === undefined) {
+        return undefined;
+    }
+    return (context.isPnlPositive === true &&
+        context.isOpen === false &&
+        context.protectionCloseFactor > 0 &&
+        context.currentBlock <=
+            context.createdBlock + context.protectionCloseFactorBlocks &&
+        context.protectionCloseFactorWhitelist !== true);
+};
+exports.isProtectionCloseFactorActive = isProtectionCloseFactorActive;
+/**
+ * @dev Gets the cumulative factor for price impact calculation
+ * @param context Cumulative volume context
+ * @returns Cumulative factor (default 1)
+ */
+const getCumulativeFactor = (context) => {
+    if (context === undefined ||
+        context.cumulativeFactor === undefined ||
+        context.cumulativeFactor === 0) {
+        return constants_1.DEFAULT_CUMULATIVE_FACTOR;
+    }
+    return context.cumulativeFactor;
+};
+exports.getCumulativeFactor = getCumulativeFactor;
+/**
+ * @dev Gets the legacy factor for v9.2 compatibility
+ * @param context Cumulative volume context
+ * @returns 1 for pre-v9.2, 2 for v9.2+
+ */
+const getLegacyFactor = (context) => {
+    return context?.contractsVersion === types_1.ContractsVersion.BEFORE_V9_2 ? 1 : 2;
+};
+exports.getLegacyFactor = getLegacyFactor;
+/**
+ * @dev Mirrors contract's _calculateDepthBandsPriceImpact function
+ * @param tradeSizeUsd Trade size in USD (always positive here)
+ * @param depthBandParams Depth band parameters
+ * @returns Price impact percentage
+ */
+const _calculateDepthBandsPriceImpact = (tradeSizeUsd, depthBandParams) => {
+    const totalDepthUsd = depthBandParams.depthBands.totalDepthUsd;
+    if (totalDepthUsd === 0 || tradeSizeUsd === 0)
+        return 0;
+    let remainingSizeUsd = tradeSizeUsd;
+    let totalWeightedPriceImpactP = 0;
+    let prevBandDepthUsd = 0;
+    let topOfPrevBandOffsetPpm = 0;
+    for (let i = 0; i < 30 && remainingSizeUsd !== 0; i++) {
+        const bandLiquidityPercentageBps = depthBandParams.depthBands.bands[i]; // Already in 0-1 format
+        const topOfBandOffsetPpm = depthBandParams.depthBandsMapping.bands[i]; // Already in 0-1 format
+        const bandDepthUsd = bandLiquidityPercentageBps * totalDepthUsd;
+        // Skip if band has same depth as previous (would cause division by zero)
+        if (bandDepthUsd <= prevBandDepthUsd) {
+            prevBandDepthUsd = bandDepthUsd;
+            topOfPrevBandOffsetPpm = topOfBandOffsetPpm;
+            continue;
+        }
+        // Since bandDepthUsd represents liquidity from mid price to top of band, we need to subtract previous band depth
+        const bandAvailableDepthUsd = bandDepthUsd - prevBandDepthUsd;
+        let depthConsumedUsd;
+        // At 100% band always consume all remaining size, even if more than band available depth
+        if (bandLiquidityPercentageBps === 1 ||
+            remainingSizeUsd <= bandAvailableDepthUsd) {
+            depthConsumedUsd = remainingSizeUsd;
+            remainingSizeUsd = 0;
+        }
+        else {
+            // Normal case: consume entire band and continue to next
+            depthConsumedUsd = bandAvailableDepthUsd;
+            remainingSizeUsd -= bandAvailableDepthUsd;
+        }
+        // Calculate impact contribution from this band using trapezoidal rule
+        // Low = previous band's price offset, High = current band's price offset
+        const lowOffsetP = topOfPrevBandOffsetPpm;
+        const offsetRangeP = topOfBandOffsetPpm - topOfPrevBandOffsetPpm;
+        // Calculate average impact using trapezoidal rule: low + (range * fraction / 2)
+        const avgImpactP = lowOffsetP +
+            (offsetRangeP * depthConsumedUsd) / bandAvailableDepthUsd / 2;
+        totalWeightedPriceImpactP += avgImpactP * depthConsumedUsd;
+        // Update previous values for next iteration
+        topOfPrevBandOffsetPpm = topOfBandOffsetPpm;
+        prevBandDepthUsd = bandDepthUsd;
+    }
+    return totalWeightedPriceImpactP / tradeSizeUsd;
+};
+/**
+ * @dev Mirrors contract's _getDepthBandsPriceImpactP function
+ * @param cumulativeVolumeUsd Cumulative volume in USD (can be negative)
+ * @param tradeSizeUsd Trade size in USD (can be negative)
+ * @param depthBandParams Depth band parameters (contains both pair bands and global mapping)
+ * @param priceImpactFactor Price impact factor (protection close factor)
+ * @param cumulativeFactor Cumulative factor for volume impact
+ * @returns Price impact percentage (can be negative)
+ */
+const _getDepthBandsPriceImpactP = (cumulativeVolumeUsd, tradeSizeUsd, depthBandParams, priceImpactFactor, cumulativeFactor) => {
+    // Check for opposite signs
+    if ((cumulativeVolumeUsd > 0 && tradeSizeUsd < 0) ||
+        (cumulativeVolumeUsd < 0 && tradeSizeUsd > 0)) {
+        throw new Error("Wrong params: cumulative volume and trade size have opposite signs");
+    }
+    const effectiveCumulativeVolumeUsd = cumulativeVolumeUsd * cumulativeFactor;
+    const totalSizeLookupUsd = effectiveCumulativeVolumeUsd + tradeSizeUsd;
+    const isNegative = totalSizeLookupUsd < 0;
+    const effectiveCumulativeVolumeUsdUint = isNegative
+        ? -effectiveCumulativeVolumeUsd
+        : effectiveCumulativeVolumeUsd;
+    const totalSizeLookupUsdUint = isNegative
+        ? -totalSizeLookupUsd
+        : totalSizeLookupUsd;
+    const cumulativeVolPriceImpactP = _calculateDepthBandsPriceImpact(effectiveCumulativeVolumeUsdUint, depthBandParams);
+    const totalSizePriceImpactP = _calculateDepthBandsPriceImpact(totalSizeLookupUsdUint, depthBandParams);
+    const unscaledPriceImpactP = cumulativeVolPriceImpactP +
+        (totalSizePriceImpactP - cumulativeVolPriceImpactP) / 2;
+    const scaledPriceImpactP = unscaledPriceImpactP * priceImpactFactor;
+    return isNegative ? -scaledPriceImpactP : scaledPriceImpactP;
+};
+/**
+ * @dev Calculates cumulative volume price impact percentage
+ * @dev Mirrors contract's getTradeCumulVolPriceImpactP function
+ * @param trader Trader address
+ * @param pairIndex Trading pair index
+ * @param long True for long, false for short
+ * @param tradeOpenInterestUsd Position size in USD
+ * @param isPnlPositive Whether PnL is positive (only relevant when closing)
+ * @param open True for opening, false for closing
+ * @param lastPosIncreaseBlock Last block when position was increased (only relevant when closing)
+ * @param context Additional context with depths, OI data, and factors
+ * @returns Cumulative volume price impact percentage (not including spread)
+ */
+const getTradeCumulVolPriceImpactP = (_trader, // Unused - kept for compatibility
+_pairIndex, // Unused - kept for compatibility
+long, tradeOpenInterestUsd, isPnlPositive, open, lastPosIncreaseBlock, context) => {
+    // Update context with passed parameters
+    const updatedContext = {
+        ...context,
+        isOpen: open,
+        isPnlPositive: isPnlPositive,
+        createdBlock: context.createdBlock || lastPosIncreaseBlock,
+    };
+    if (
+    // No price impact when closing pre-v9.2 trades
+    (!open && context?.contractsVersion === types_1.ContractsVersion.BEFORE_V9_2) ||
+        // No price impact for opens when `pair.exemptOnOpen` is true
+        (open && context?.exemptOnOpen === true) ||
+        // No price impact for closes after `protectionCloseFactor` has expired
+        // when `pair.exemptAfterProtectionCloseFactor` is true
+        (!open &&
+            context?.exemptAfterProtectionCloseFactor === true &&
+            (0, exports.isProtectionCloseFactorActive)(updatedContext) !== true)) {
+        return 0;
+    }
+    const tradePositiveSkew = (long && open) || (!long && !open);
+    const tradeSkewMultiplier = tradePositiveSkew ? 1 : -1;
+    if (!context.pairDepthBands || !context.depthBandsMapping) {
+        return 0;
+    }
+    // Select depth bands based on trade direction
+    const depthBands = tradePositiveSkew
+        ? context.pairDepthBands.above
+        : context.pairDepthBands.below;
+    // Return 0 if no depth bands configured (matching contract lines 588-590)
+    if (!depthBands || depthBands.totalDepthUsd === 0) {
+        return 0;
+    }
+    // Get active OI for cumulative volume calculation
+    let activeOi = 0;
+    if (context.oiWindowsSettings !== undefined) {
+        activeOi =
+            (0, oiWindows_1.getActiveOi)((0, oiWindows_1.getCurrentOiWindowId)(context.oiWindowsSettings), context.oiWindowsSettings.windowsCount, context.oiWindows, open ? long : !long) || 0;
+    }
+    const signedActiveOi = activeOi * tradeSkewMultiplier;
+    const signedTradeOi = tradeOpenInterestUsd * tradeSkewMultiplier;
+    // Calculate price impact using depth bands
+    const priceImpactP = _getDepthBandsPriceImpactP(signedActiveOi, signedTradeOi, {
+        depthBands: depthBands,
+        depthBandsMapping: context.depthBandsMapping,
+    }, (0, exports.getProtectionCloseFactor)(updatedContext), (0, exports.getCumulativeFactor)(updatedContext));
+    return priceImpactP;
+};
+exports.getTradeCumulVolPriceImpactP = getTradeCumulVolPriceImpactP;
+/**
+ * @dev Gets the fixed spread percentage with direction
+ * @dev Mirrors contract's getFixedSpreadP function
+ * @param spreadP Total spread percentage (includes base + user spread)
+ * @param long True for long position
+ * @param open True for opening, false for closing
+ * @returns Signed spread percentage (positive or negative based on direction)
+ */
+const getFixedSpreadP = (spreadP, long, open) => {
+    // Reverse spread direction on close
+    const effectiveLong = open ? long : !long;
+    // Calculate half spread
+    const fixedSpreadP = spreadP / 2;
+    // Apply direction
+    return effectiveLong ? fixedSpreadP : -fixedSpreadP;
+};
+exports.getFixedSpreadP = getFixedSpreadP;
+/**
+ * @dev Gets the base spread percentage
+ * @param pairSpreadP Pair spread percentage
+ * @param isLiquidation True if liquidation
+ * @param liquidationParams Liquidation parameters
+ * @param userPriceImpact User-specific price impact settings
+ * @returns Base spread percentage
+ * @todo Review if this function still makes sense or should use getFixedSpreadP pattern
+ *       Currently it may double-count user fixed spread if pairSpreadP already includes it
+ */
+const getSpreadP = (pairSpreadP, isLiquidation, liquidationParams, userPriceImpact) => {
+    const fixedSpreadP = userPriceImpact?.fixedSpreadP ?? 0;
+    if (pairSpreadP === undefined || (pairSpreadP === 0 && fixedSpreadP === 0)) {
+        return 0;
+    }
+    const spreadP = pairSpreadP / 2 + fixedSpreadP;
+    return isLiquidation === true &&
+        liquidationParams !== undefined &&
+        liquidationParams.maxLiqSpreadP > 0 &&
+        spreadP > liquidationParams.maxLiqSpreadP
+        ? liquidationParams.maxLiqSpreadP
+        : spreadP;
+};
+exports.getSpreadP = getSpreadP;
+/**
+ * @dev Gets spread with cumulative volume price impact
+ * @dev This combines base spread + cumulative volume impact
+ * @param pairSpreadP Base pair spread percentage
+ * @param buy True for long, false for short
+ * @param collateral Collateral amount
+ * @param leverage Position leverage
+ * @param oiWindowsSettings OI windows configuration
+ * @param oiWindows Current OI windows data
+ * @param context Additional context for the calculation
+ * @returns Total spread + cumulative volume price impact percentage
+ */
+const getSpreadWithCumulVolPriceImpactP = (pairSpreadP, buy, collateral, leverage, context) => {
+    if (pairSpreadP === undefined) {
+        return 0;
+    }
+    const baseSpread = (0, exports.getSpreadP)(pairSpreadP, undefined, undefined, context?.userPriceImpact);
+    // Calculate position size in USD
+    const positionSizeUsd = collateral * leverage * (context?.collateralPriceUsd || 1);
+    const cumulVolImpact = (0, exports.getTradeCumulVolPriceImpactP)("", // trader - not used in calculation
+    0, // pairIndex - not used in calculation
+    buy, positionSizeUsd, context?.isPnlPositive || false, context?.isOpen !== false, context?.createdBlock || 0, context);
+    return baseSpread + cumulVolImpact;
+};
+exports.getSpreadWithCumulVolPriceImpactP = getSpreadWithCumulVolPriceImpactP;
+/**
+ * @dev Convenience function for calculating cumulative volume price impact
+ * @dev Uses collateral and leverage instead of USD position size
+ * @param buy True for long, false for short
+ * @param collateral Collateral amount
+ * @param leverage Position leverage
+ * @param open True for opening, false for closing
+ * @param context Full context including depths, OI data, and collateral price
+ * @returns Cumulative volume price impact percentage
+ */
+const getCumulVolPriceImpact = (buy, collateral, leverage, open, context) => {
+    const positionSizeUsd = collateral * leverage * context.collateralPriceUsd;
+    return (0, exports.getTradeCumulVolPriceImpactP)("", // trader - not used in calculation
+    0, // pairIndex - not used in calculation
+    buy, positionSizeUsd, context.isPnlPositive || false, open, context.createdBlock || 0, context);
+};
+exports.getCumulVolPriceImpact = getCumulVolPriceImpact;
+// Legacy export for backward compatibility
+exports.getSpreadWithPriceImpactP = exports.getSpreadWithCumulVolPriceImpactP;
+// Export converters
+var converter_1 = require("./converter");
+Object.defineProperty(exports, "convertOiWindowsSettings", { enumerable: true, get: function () { return converter_1.convertOiWindowsSettings; } });
+Object.defineProperty(exports, "convertOiWindow", { enumerable: true, get: function () { return converter_1.convertOiWindow; } });
+Object.defineProperty(exports, "convertOiWindows", { enumerable: true, get: function () { return converter_1.convertOiWindows; } });
+Object.defineProperty(exports, "convertOiWindowsSettingsArray", { enumerable: true, get: function () { return converter_1.convertOiWindowsSettingsArray; } });
+// Export builder
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildCumulVolContext", { enumerable: true, get: function () { return builder_1.buildCumulVolContext; } });

package/lib/trade/priceImpact/cumulVol/types.d.ts

@@ -0,0 +1,11 @@
+export type DepthBands = {
+    totalDepthUsd: number;
+    bands: number[];
+};
+export type PairDepthBands = {
+    above: DepthBands | undefined;
+    below: DepthBands | undefined;
+};
+export type DepthBandsMapping = {
+    bands: number[];
+};

package/lib/trade/priceImpact/cumulVol/types.js

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

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

@@ -0,0 +1,21 @@
+/**
+ * @dev Main price impact module
+ * @dev Exports cumulative volume, skew, and combined opening/closing price impact functionality
+ */
+/**
+ * @dev Calculates price after impact using the same formula as the Solidity contract
+ * @dev Mirrors contract's getPriceAfterImpact function
+ * @param oraclePrice Base oracle price (no decimals requirement)
+ * @param totalPriceImpactP Total price impact percentage (can be positive or negative)
+ * @returns Price after impact has been applied
+ */
+export declare const getPriceAfterImpact: (oraclePrice: number, totalPriceImpactP: number) => number;
+export { getTradeOpeningPriceImpact, getTradeOpeningPriceImpactAtMarket, buildTradeOpeningPriceImpactContext, TradeOpeningPriceImpactInput, TradeOpeningPriceImpactContext, TradeOpeningPriceImpactResult, } from "./open";
+export { getTradeClosingPriceImpact, getTradeClosingPriceImpactAtOracle, buildTradeClosingPriceImpactContext, TradeClosingPriceImpactInput, TradeClosingPriceImpactContext, TradeClosingPriceImpactResult, } from "./close";
+export { getTradeCumulVolPriceImpactP, getCumulVolPriceImpact, // Convenience function
+getSpreadWithCumulVolPriceImpactP, getSpreadWithPriceImpactP, // Legacy alias
+getProtectionCloseFactor, isProtectionCloseFactorActive, getCumulativeFactor, getLegacyFactor, getFixedSpreadP, getSpreadP, convertOiWindowsSettings, convertOiWindow, convertOiWindows, convertOiWindowsSettingsArray, buildCumulVolContext, CumulVolContext, } from "./cumulVol";
+export { getNetSkewToken, getNetSkewCollateral, getTradeSkewDirection, calculateSkewPriceImpactP, getTradeSkewPriceImpact, calculatePartialSizeToken, SkewPriceImpact, } from "./skew";
+export { convertPairOiToken, convertPairOiTokenArray, convertPairOiCollateral, convertPairOiCollateralArray, convertSkewDepth, convertPairSkewDepths, } from "./skew/converter";
+export { buildSkewPriceImpactContext } from "./skew/builder";
+export type { PairOiToken, PairOiCollateral, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext, TradeSkewParams, PositionSizeResult, } from "./skew/types";

package/lib/trade/priceImpact/index.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * @dev Main price impact module
+ * @dev Exports cumulative volume, skew, and combined opening/closing price impact functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSkewPriceImpactContext = exports.convertPairSkewDepths = exports.convertSkewDepth = exports.convertPairOiCollateralArray = exports.convertPairOiCollateral = exports.convertPairOiTokenArray = exports.convertPairOiToken = exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = exports.buildCumulVolContext = exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = exports.getSpreadP = exports.getFixedSpreadP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = exports.getSpreadWithPriceImpactP = exports.getSpreadWithCumulVolPriceImpactP = exports.getCumulVolPriceImpact = exports.getTradeCumulVolPriceImpactP = exports.buildTradeClosingPriceImpactContext = exports.getTradeClosingPriceImpactAtOracle = exports.getTradeClosingPriceImpact = exports.buildTradeOpeningPriceImpactContext = exports.getTradeOpeningPriceImpactAtMarket = exports.getTradeOpeningPriceImpact = exports.getPriceAfterImpact = void 0;
+/**
+ * @dev Calculates price after impact using the same formula as the Solidity contract
+ * @dev Mirrors contract's getPriceAfterImpact function
+ * @param oraclePrice Base oracle price (no decimals requirement)
+ * @param totalPriceImpactP Total price impact percentage (can be positive or negative)
+ * @returns Price after impact has been applied
+ */
+const getPriceAfterImpact = (oraclePrice, totalPriceImpactP) => {
+    // Match Solidity: price = oraclePrice + (oraclePrice * totalPriceImpactP / 100)
+    const priceAfterImpact = oraclePrice * (1 + totalPriceImpactP / 100);
+    if (priceAfterImpact <= 0) {
+        throw new Error("Price after impact must be positive");
+    }
+    return priceAfterImpact;
+};
+exports.getPriceAfterImpact = getPriceAfterImpact;
+// Export trade opening price impact functionality
+var open_1 = require("./open");
+// Core functions
+Object.defineProperty(exports, "getTradeOpeningPriceImpact", { enumerable: true, get: function () { return open_1.getTradeOpeningPriceImpact; } });
+Object.defineProperty(exports, "getTradeOpeningPriceImpactAtMarket", { enumerable: true, get: function () { return open_1.getTradeOpeningPriceImpactAtMarket; } });
+// Builder
+Object.defineProperty(exports, "buildTradeOpeningPriceImpactContext", { enumerable: true, get: function () { return open_1.buildTradeOpeningPriceImpactContext; } });
+// Export trade closing price impact functionality
+var close_1 = require("./close");
+// Core functions
+Object.defineProperty(exports, "getTradeClosingPriceImpact", { enumerable: true, get: function () { return close_1.getTradeClosingPriceImpact; } });
+Object.defineProperty(exports, "getTradeClosingPriceImpactAtOracle", { enumerable: true, get: function () { return close_1.getTradeClosingPriceImpactAtOracle; } });
+// Builder
+Object.defineProperty(exports, "buildTradeClosingPriceImpactContext", { enumerable: true, get: function () { return close_1.buildTradeClosingPriceImpactContext; } });
+// Export cumulative volume price impact functionality
+var cumulVol_1 = require("./cumulVol");
+// Core functions
+Object.defineProperty(exports, "getTradeCumulVolPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getTradeCumulVolPriceImpactP; } });
+Object.defineProperty(exports, "getCumulVolPriceImpact", { enumerable: true, get: function () { return cumulVol_1.getCumulVolPriceImpact; } });
+Object.defineProperty(exports, "getSpreadWithCumulVolPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getSpreadWithCumulVolPriceImpactP; } });
+Object.defineProperty(exports, "getSpreadWithPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getSpreadWithPriceImpactP; } });
+Object.defineProperty(exports, "getProtectionCloseFactor", { enumerable: true, get: function () { return cumulVol_1.getProtectionCloseFactor; } });
+Object.defineProperty(exports, "isProtectionCloseFactorActive", { enumerable: true, get: function () { return cumulVol_1.isProtectionCloseFactorActive; } });
+Object.defineProperty(exports, "getCumulativeFactor", { enumerable: true, get: function () { return cumulVol_1.getCumulativeFactor; } });
+Object.defineProperty(exports, "getLegacyFactor", { enumerable: true, get: function () { return cumulVol_1.getLegacyFactor; } });
+Object.defineProperty(exports, "getFixedSpreadP", { enumerable: true, get: function () { return cumulVol_1.getFixedSpreadP; } });
+Object.defineProperty(exports, "getSpreadP", { enumerable: true, get: function () { return cumulVol_1.getSpreadP; } });
+// Converters
+Object.defineProperty(exports, "convertOiWindowsSettings", { enumerable: true, get: function () { return cumulVol_1.convertOiWindowsSettings; } });
+Object.defineProperty(exports, "convertOiWindow", { enumerable: true, get: function () { return cumulVol_1.convertOiWindow; } });
+Object.defineProperty(exports, "convertOiWindows", { enumerable: true, get: function () { return cumulVol_1.convertOiWindows; } });
+Object.defineProperty(exports, "convertOiWindowsSettingsArray", { enumerable: true, get: function () { return cumulVol_1.convertOiWindowsSettingsArray; } });
+// Builder
+Object.defineProperty(exports, "buildCumulVolContext", { enumerable: true, get: function () { return cumulVol_1.buildCumulVolContext; } });
+// Export skew price impact functionality
+var skew_1 = require("./skew");
+// Core functions
+Object.defineProperty(exports, "getNetSkewToken", { enumerable: true, get: function () { return skew_1.getNetSkewToken; } });
+Object.defineProperty(exports, "getNetSkewCollateral", { enumerable: true, get: function () { return skew_1.getNetSkewCollateral; } });
+Object.defineProperty(exports, "getTradeSkewDirection", { enumerable: true, get: function () { return skew_1.getTradeSkewDirection; } });
+Object.defineProperty(exports, "calculateSkewPriceImpactP", { enumerable: true, get: function () { return skew_1.calculateSkewPriceImpactP; } });
+Object.defineProperty(exports, "getTradeSkewPriceImpact", { enumerable: true, get: function () { return skew_1.getTradeSkewPriceImpact; } });
+Object.defineProperty(exports, "calculatePartialSizeToken", { enumerable: true, get: function () { return skew_1.calculatePartialSizeToken; } });
+// Types namespace
+Object.defineProperty(exports, "SkewPriceImpact", { enumerable: true, get: function () { return skew_1.SkewPriceImpact; } });
+// Export converters
+var converter_1 = require("./skew/converter");
+Object.defineProperty(exports, "convertPairOiToken", { enumerable: true, get: function () { return converter_1.convertPairOiToken; } });
+Object.defineProperty(exports, "convertPairOiTokenArray", { enumerable: true, get: function () { return converter_1.convertPairOiTokenArray; } });
+Object.defineProperty(exports, "convertPairOiCollateral", { enumerable: true, get: function () { return converter_1.convertPairOiCollateral; } });
+Object.defineProperty(exports, "convertPairOiCollateralArray", { enumerable: true, get: function () { return converter_1.convertPairOiCollateralArray; } });
+Object.defineProperty(exports, "convertSkewDepth", { enumerable: true, get: function () { return converter_1.convertSkewDepth; } });
+Object.defineProperty(exports, "convertPairSkewDepths", { enumerable: true, get: function () { return converter_1.convertPairSkewDepths; } });
+// Export builders
+var builder_1 = require("./skew/builder");
+Object.defineProperty(exports, "buildSkewPriceImpactContext", { enumerable: true, get: function () { return builder_1.buildSkewPriceImpactContext; } });

package/lib/trade/priceImpact/open/builder.d.ts

@@ -0,0 +1,21 @@
+import { GlobalTradingVariablesType } from "../../../backend/tradingVariables/types";
+import { TradeOpeningPriceImpactContext } from "./types";
+/**
+ * @dev Builds a complete context for trade opening price impact calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex The collateral index (1-based)
+ * @param pairIndex The pair index
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getTradeOpeningPriceImpact
+ */
+export declare const buildTradeOpeningPriceImpactContext: (globalTradingVariables: GlobalTradingVariablesType, collateralIndex: number, pairIndex: number, additionalParams: {
+    currentBlock: number;
+    contractsVersion?: number;
+    trader?: string;
+    userPriceImpact?: {
+        cumulVolPriceImpactMultiplier: number;
+        fixedSpreadP: number;
+    };
+    protectionCloseFactorWhitelist?: boolean;
+}) => TradeOpeningPriceImpactContext | undefined;

package/lib/trade/priceImpact/open/builder.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTradeOpeningPriceImpactContext = void 0;
+const builder_1 = require("../cumulVol/builder");
+const builder_2 = require("../skew/builder");
+/**
+ * @dev Builds a complete context for trade opening price impact calculations
+ * @dev Uses sub-context builders to create properly scoped contexts
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex The collateral index (1-based)
+ * @param pairIndex The pair index
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getTradeOpeningPriceImpact
+ */
+const buildTradeOpeningPriceImpactContext = (globalTradingVariables, collateralIndex, pairIndex, additionalParams) => {
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!collateral) {
+        return undefined;
+    }
+    // Build cumulative volume subcontext
+    const cumulVolContext = (0, builder_1.buildCumulVolContext)(globalTradingVariables, collateralIndex, pairIndex, {
+        currentBlock: additionalParams.currentBlock,
+        contractsVersion: additionalParams.contractsVersion,
+        isPnlPositive: false,
+        isOpen: true,
+        createdBlock: undefined,
+        userPriceImpact: additionalParams.userPriceImpact,
+        protectionCloseFactorWhitelist: additionalParams.protectionCloseFactorWhitelist,
+    });
+    // Build skew price impact subcontext
+    const skewContext = (0, builder_2.buildSkewPriceImpactContext)(collateral, pairIndex);
+    if (!cumulVolContext || !skewContext) {
+        return undefined;
+    }
+    // Return structured context with proper subcontexts
+    return {
+        collateralPriceUsd: collateral.prices?.collateralPriceUsd || 1,
+        cumulVolContext,
+        skewContext,
+    };
+};
+exports.buildTradeOpeningPriceImpactContext = buildTradeOpeningPriceImpactContext;

package/lib/trade/priceImpact/open/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @dev Trade opening price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeOpeningPriceImpact
+ */
+import { TradeOpeningPriceImpactInput, TradeOpeningPriceImpactContext, TradeOpeningPriceImpactResult } from "./types";
+export type { TradeOpeningPriceImpactInput, TradeOpeningPriceImpactContext, TradeOpeningPriceImpactResult, };
+export { buildTradeOpeningPriceImpactContext } from "./builder";
+/**
+ * @dev Calculates all price impacts for trade opening
+ * @dev Mirrors contract's getTradeOpeningPriceImpact function
+ * @param input Trade parameters
+ * @param context Combined context for calculations
+ * @returns Price impact breakdown and final price
+ */
+export declare const getTradeOpeningPriceImpact: (input: TradeOpeningPriceImpactInput, context: TradeOpeningPriceImpactContext) => TradeOpeningPriceImpactResult;
+/**
+ * @dev Simplified version using current market price
+ * @param input Trade parameters
+ * @param context Combined context
+ * @param currentMarketPrice Current market price to use as open price
+ * @returns Price impact breakdown and final price
+ */
+export declare const getTradeOpeningPriceImpactAtMarket: (input: Omit<TradeOpeningPriceImpactInput, "openPrice">, context: TradeOpeningPriceImpactContext, currentMarketPrice: number) => TradeOpeningPriceImpactResult;

package/lib/trade/priceImpact/open/index.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * @dev Trade opening price impact calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeOpeningPriceImpact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeOpeningPriceImpactAtMarket = exports.getTradeOpeningPriceImpact = exports.buildTradeOpeningPriceImpactContext = void 0;
+const cumulVol_1 = require("../cumulVol");
+const skew_1 = require("../skew");
+const __1 = require("../");
+// Export builder
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildTradeOpeningPriceImpactContext", { enumerable: true, get: function () { return builder_1.buildTradeOpeningPriceImpactContext; } });
+/**
+ * @dev Calculates all price impacts for trade opening
+ * @dev Mirrors contract's getTradeOpeningPriceImpact function
+ * @param input Trade parameters
+ * @param context Combined context for calculations
+ * @returns Price impact breakdown and final price
+ */
+const getTradeOpeningPriceImpact = (input, context) => {
+    const positionSizeCollateral = input.collateralAmount * input.leverage;
+    // Calculate fixed spread
+    const spreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.long, true // opening
+    );
+    // Calculate position size in USD
+    const positionSizeUsd = positionSizeCollateral * context.collateralPriceUsd;
+    // Calculate cumulative volume price impact
+    const cumulVolPriceImpactP = (0, cumulVol_1.getTradeCumulVolPriceImpactP)("", // trader - not needed for calculation
+    input.pairIndex, input.long, positionSizeUsd, false, // isPnlPositive - not relevant for opening
+    true, // open
+    0, // lastPosIncreaseBlock - not relevant for opening
+    context.cumulVolContext);
+    // Calculate price after spread and cumulative volume impact (before skew)
+    const priceAfterSpreadAndCumulVolPriceImpact = (0, __1.getPriceAfterImpact)(input.openPrice, spreadP + cumulVolPriceImpactP);
+    // Calculate position size in tokens using the price after fixed spread and cumul vol impact
+    const positionSizeToken = positionSizeCollateral / priceAfterSpreadAndCumulVolPriceImpact;
+    // Calculate skew price impact (v10+ only)
+    const skewPriceImpactObject = (0, skew_1.getTradeSkewPriceImpact)({
+        collateralIndex: input.collateralIndex,
+        pairIndex: input.pairIndex,
+        long: input.long,
+        open: true,
+        positionSizeToken,
+    }, context.skewContext);
+    const skewPriceImpactP = skewPriceImpactObject.totalPriceImpactP;
+    // Total price impact (signed - can be positive or negative)
+    const totalPriceImpactP = spreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    const totalPriceImpactPFromMarketPrice = spreadP + cumulVolPriceImpactP + skewPriceImpactObject.tradePriceImpactP;
+    // Calculate final price after impact using the same formula as Solidity
+    const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.openPrice, totalPriceImpactP);
+    // Calculate percent profit from impact
+    // For longs: negative impact = profit (price goes down, good for buyer)
+    // For shorts: positive impact = profit (price goes up, good for seller)
+    const percentProfitP = -totalPriceImpactP;
+    return {
+        priceAfterImpact,
+        percentProfitP,
+        fixedSpreadP: spreadP,
+        cumulVolPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
+        totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
+    };
+};
+exports.getTradeOpeningPriceImpact = getTradeOpeningPriceImpact;
+/**
+ * @dev Simplified version using current market price
+ * @param input Trade parameters
+ * @param context Combined context
+ * @param currentMarketPrice Current market price to use as open price
+ * @returns Price impact breakdown and final price
+ */
+const getTradeOpeningPriceImpactAtMarket = (input, context, currentMarketPrice) => {
+    return (0, exports.getTradeOpeningPriceImpact)({
+        ...input,
+        openPrice: currentMarketPrice,
+    }, context);
+};
+exports.getTradeOpeningPriceImpactAtMarket = getTradeOpeningPriceImpactAtMarket;

package/lib/trade/priceImpact/open/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @dev Types for trade opening price impact calculations
+ */
+import { CumulVolContext } from "../cumulVol";
+import { SkewPriceImpactContext } from "../skew/types";
+import { Fee, PairIndex } from "../../types";
+/**
+ * @dev Input parameters for trade opening price impact
+ */
+export type TradeOpeningPriceImpactInput = {
+    collateralIndex: number;
+    pairIndex: PairIndex;
+    long: boolean;
+    collateralAmount: number;
+    leverage: number;
+    openPrice: number;
+    pairSpreadP: number;
+    fee: Fee;
+    contractsVersion: number;
+    isCounterTrade?: boolean;
+};
+/**
+ * @dev Context for trade opening price impact calculation
+ * Combines contexts from spread, cumul vol, and skew
+ */
+export type TradeOpeningPriceImpactContext = {
+    collateralPriceUsd: number;
+    cumulVolContext: CumulVolContext;
+    skewContext: SkewPriceImpactContext;
+};
+/**
+ * @dev Result of trade opening price impact calculation
+ * Mirrors contract's PriceImpact struct
+ */
+export type TradeOpeningPriceImpactResult = {
+    priceAfterImpact: number;
+    percentProfitP: number;
+    fixedSpreadP: number;
+    cumulVolPriceImpactP: number;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
+    totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: number;
+};