@gainsnetwork/sdk 1.4.5 → 1.5.0-rc1

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }) // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 &&
+        tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, undefined, // pairIndex not needed for pair-specific context
+        trade.long, context.borrowingV1.initialAccFees || {
+            accPairFee: 0,
+            accGroupFee: 0,
+            block: 0,
+        }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

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

@@ -15,7 +15,8 @@ const buildCumulVolContext = (globalTradingVariables, collateralIndex, pairIndex
         return undefined;
     }
     // Get pair-specific data from global variables
-    const pairDepth = globalTradingVariables.pairDepths?.[pairIndex];
+    const pairDepthBands = globalTradingVariables.pairDepthBands?.[pairIndex];
+    const depthBandsMapping = globalTradingVariables.depthBandsMapping;
     const pairFactor = globalTradingVariables.pairFactors?.[pairIndex];
     const oiWindows = globalTradingVariables.oiWindows?.[pairIndex];
     // Get OI windows settings (same for all pairs)
@@ -38,7 +39,8 @@ const buildCumulVolContext = (globalTradingVariables, collateralIndex, pairIndex
         contractsVersion: additionalParams.contractsVersion,
         protectionCloseFactorWhitelist,
         // Price impact data
-        pairDepth,
+        pairDepthBands,
+        depthBandsMapping,
         oiWindowsSettings,
         oiWindows,
         // User/collateral specific

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

@@ -4,6 +4,7 @@
  */
 import { IPriceImpact } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
 import { OiWindowsSettings, OiWindow, OiWindows } from "../../types";
+import { DepthBands, PairDepthBands, DepthBandsMapping } from "./types";
 /**
  * @dev Converts contract OI windows settings to SDK format
  * @param contractData Contract OiWindowsSettings struct
@@ -29,3 +30,65 @@ export declare const convertOiWindows: (windowIds: string[], contractWindows: IP
  * @returns Array of normalized OI windows settings
  */
 export declare const convertOiWindowsSettingsArray: (contractDataArray: IPriceImpact.OiWindowsSettingsStructOutput[]) => OiWindowsSettings[];
+/**
+ * @dev Converts decoded depth bands from contract to SDK format
+ * @param totalDepthUsd Total depth in USD (already decoded from contract)
+ * @param bandsBps Array of 30 band percentages in basis points from contract
+ * @returns Normalized depth bands with bands in 0-1 range
+ */
+export declare const convertDepthBands: (totalDepthUsd: number, bandsBps: number[]) => DepthBands;
+/**
+ * @dev Converts decoded pair depth bands from contract to SDK format
+ * @param aboveDepth Decoded above depth bands from getPairDepthBandsDecoded
+ * @param belowDepth Decoded below depth bands from getPairDepthBandsDecoded
+ * @returns Normalized pair depth bands with above/below
+ */
+export declare const convertPairDepthBands: (aboveDepth: {
+    totalDepthUsd: number;
+    bands: number[];
+} | undefined, belowDepth: {
+    totalDepthUsd: number;
+    bands: number[];
+} | undefined) => PairDepthBands;
+/**
+ * @dev Converts decoded depth bands mapping from contract to SDK format
+ * @param bandsBps Array of 30 band offset values in basis points from getDepthBandsMappingDecoded
+ * @returns Normalized depth bands mapping with offset values in 0-1 range
+ */
+export declare const convertDepthBandsMapping: (bandsBps: number[]) => DepthBandsMapping;
+/**
+ * @dev Validates depth bands have correct number of bands
+ * @param depthBands Depth bands to validate
+ * @returns True if valid (30 bands)
+ */
+export declare const validateDepthBands: (depthBands: DepthBands) => boolean;
+/**
+ * @dev Validates depth bands mapping has correct number of bands
+ * @param mapping Depth bands mapping to validate
+ * @returns True if valid (30 bands)
+ */
+export declare const validateDepthBandsMapping: (mapping: DepthBandsMapping) => boolean;
+/**
+ * @dev Alternative converter for decoded pair depth bands from contract
+ * @param contractData Decoded pair depth bands from getPairDepthBandsDecoded
+ * @returns Normalized pair depth bands
+ */
+export declare const convertPairDepthBandsDecoded: (contractData: {
+    above: {
+        totalDepthUsd: number;
+        bands: number[];
+    };
+    below: {
+        totalDepthUsd: number;
+        bands: number[];
+    };
+}) => PairDepthBands;
+/**
+ * @dev Alternative converter for raw slot-based pair depth bands (if needed for legacy)
+ * @param aboveSlot1 First slot for above bands
+ * @param aboveSlot2 Second slot for above bands
+ * @param belowSlot1 First slot for below bands
+ * @param belowSlot2 Second slot for below bands
+ * @returns Normalized pair depth bands
+ */
+export declare const convertPairDepthBandsFromSlots: (aboveSlot1: bigint, aboveSlot2: bigint, belowSlot1: bigint, belowSlot2: bigint) => PairDepthBands;

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

@@ -4,7 +4,8 @@
  * @dev All BigNumber values are normalized to floats with appropriate precision
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = void 0;
+exports.convertPairDepthBandsFromSlots = exports.convertPairDepthBandsDecoded = exports.validateDepthBandsMapping = exports.validateDepthBands = exports.convertDepthBandsMapping = exports.convertPairDepthBands = exports.convertDepthBands = exports.convertOiWindowsSettingsArray = exports.convertOiWindows = exports.convertOiWindow = exports.convertOiWindowsSettings = void 0;
+const depthBands_1 = require("../../../pricing/depthBands");
 /**
  * @dev Converts contract OI windows settings to SDK format
  * @param contractData Contract OiWindowsSettings struct
@@ -57,3 +58,98 @@ const convertOiWindowsSettingsArray = (contractDataArray) => {
     return contractDataArray.map(exports.convertOiWindowsSettings);
 };
 exports.convertOiWindowsSettingsArray = convertOiWindowsSettingsArray;
+/**
+ * @dev Converts decoded depth bands from contract to SDK format
+ * @param totalDepthUsd Total depth in USD (already decoded from contract)
+ * @param bandsBps Array of 30 band percentages in basis points from contract
+ * @returns Normalized depth bands with bands in 0-1 range
+ */
+const convertDepthBands = (totalDepthUsd, bandsBps) => {
+    // Convert bands from basis points to 0-1 range
+    const bands = bandsBps.map(bps => bps / 10000);
+    return {
+        totalDepthUsd,
+        bands,
+    };
+};
+exports.convertDepthBands = convertDepthBands;
+/**
+ * @dev Converts decoded pair depth bands from contract to SDK format
+ * @param aboveDepth Decoded above depth bands from getPairDepthBandsDecoded
+ * @param belowDepth Decoded below depth bands from getPairDepthBandsDecoded
+ * @returns Normalized pair depth bands with above/below
+ */
+const convertPairDepthBands = (aboveDepth, belowDepth) => {
+    // Convert above bands if configured
+    const above = aboveDepth && aboveDepth.totalDepthUsd > 0
+        ? (0, exports.convertDepthBands)(aboveDepth.totalDepthUsd, aboveDepth.bands)
+        : undefined;
+    // Convert below bands if configured
+    const below = belowDepth && belowDepth.totalDepthUsd > 0
+        ? (0, exports.convertDepthBands)(belowDepth.totalDepthUsd, belowDepth.bands)
+        : undefined;
+    return {
+        above,
+        below,
+    };
+};
+exports.convertPairDepthBands = convertPairDepthBands;
+/**
+ * @dev Converts decoded depth bands mapping from contract to SDK format
+ * @param bandsBps Array of 30 band offset values in basis points from getDepthBandsMappingDecoded
+ * @returns Normalized depth bands mapping with offset values in 0-1 range
+ */
+const convertDepthBandsMapping = (bandsBps) => {
+    // Convert bands from basis points to 0-1 range
+    const bands = bandsBps.map(bps => bps / 10000);
+    return {
+        bands,
+    };
+};
+exports.convertDepthBandsMapping = convertDepthBandsMapping;
+/**
+ * @dev Validates depth bands have correct number of bands
+ * @param depthBands Depth bands to validate
+ * @returns True if valid (30 bands)
+ */
+const validateDepthBands = (depthBands) => {
+    return depthBands.bands.length === 30;
+};
+exports.validateDepthBands = validateDepthBands;
+/**
+ * @dev Validates depth bands mapping has correct number of bands
+ * @param mapping Depth bands mapping to validate
+ * @returns True if valid (30 bands)
+ */
+const validateDepthBandsMapping = (mapping) => {
+    return mapping.bands.length === 30;
+};
+exports.validateDepthBandsMapping = validateDepthBandsMapping;
+/**
+ * @dev Alternative converter for decoded pair depth bands from contract
+ * @param contractData Decoded pair depth bands from getPairDepthBandsDecoded
+ * @returns Normalized pair depth bands
+ */
+const convertPairDepthBandsDecoded = (contractData) => {
+    return (0, exports.convertPairDepthBands)(contractData.above, contractData.below);
+};
+exports.convertPairDepthBandsDecoded = convertPairDepthBandsDecoded;
+/**
+ * @dev Alternative converter for raw slot-based pair depth bands (if needed for legacy)
+ * @param aboveSlot1 First slot for above bands
+ * @param aboveSlot2 Second slot for above bands
+ * @param belowSlot1 First slot for below bands
+ * @param belowSlot2 Second slot for below bands
+ * @returns Normalized pair depth bands
+ */
+const convertPairDepthBandsFromSlots = (aboveSlot1, aboveSlot2, belowSlot1, belowSlot2) => {
+    // Use the decoding functions from pricing module if raw slots are provided
+    const above = aboveSlot1 !== BigInt(0) || aboveSlot2 !== BigInt(0)
+        ? (0, depthBands_1.decodeDepthBands)(aboveSlot1, aboveSlot2)
+        : undefined;
+    const below = belowSlot1 !== BigInt(0) || belowSlot2 !== BigInt(0)
+        ? (0, depthBands_1.decodeDepthBands)(belowSlot1, belowSlot2)
+        : undefined;
+    return (0, exports.convertPairDepthBands)(above, below);
+};
+exports.convertPairDepthBandsFromSlots = convertPairDepthBandsFromSlots;

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

@@ -2,7 +2,8 @@
  * @dev Cumulative volume price impact calculations
  * @dev Mirrors contract's getTradeCumulVolPriceImpactP functionality
  */
-import { LiquidationParams, OiWindows, OiWindowsSettings, PairDepth, PairFactor, UserPriceImpact } from "../../types";
+import { PairDepthBands, DepthBandsMapping } from "./types";
+import { LiquidationParams, OiWindows, OiWindowsSettings, PairFactor, UserPriceImpact } from "../../types";
 import { ContractsVersion } from "../../../contracts/types";
 export type CumulVolContext = {
     isOpen?: boolean;
@@ -12,9 +13,10 @@ export type CumulVolContext = {
     currentBlock?: number | undefined;
     contractsVersion?: ContractsVersion | undefined;
     protectionCloseFactorWhitelist?: boolean;
-    pairDepth?: PairDepth | undefined;
     oiWindowsSettings?: OiWindowsSettings | undefined;
     oiWindows?: OiWindows | undefined;
+    pairDepthBands?: PairDepthBands | undefined;
+    depthBandsMapping?: DepthBandsMapping | undefined;
     userPriceImpact?: UserPriceImpact | undefined;
     collateralPriceUsd?: number;
 } & Partial<PairFactor>;
@@ -55,7 +57,7 @@ export declare const getLegacyFactor: (context: CumulVolContext | undefined) =>
  * @param context Additional context with depths, OI data, and factors
  * @returns Cumulative volume price impact percentage (not including spread)
  */
-export declare const getTradeCumulVolPriceImpactP: (trader: string, pairIndex: number, long: boolean, tradeOpenInterestUsd: number, isPnlPositive: boolean, open: boolean, lastPosIncreaseBlock: number, context: CumulVolContext) => number;
+export declare const getTradeCumulVolPriceImpactP: (_trader: string, _pairIndex: number, long: boolean, tradeOpenInterestUsd: number, isPnlPositive: boolean, open: boolean, lastPosIncreaseBlock: number, context: CumulVolContext) => number;
 /**
  * @dev Gets the fixed spread percentage with direction
  * @dev Mirrors contract's getFixedSpreadP function
@@ -83,13 +85,12 @@ export declare const getSpreadP: (pairSpreadP: number | undefined, isLiquidation
  * @param buy True for long, false for short
  * @param collateral Collateral amount
  * @param leverage Position leverage
- * @param pairDepth 1% depth values for the pair
  * @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
  */
-export declare const getSpreadWithCumulVolPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, pairDepth: PairDepth | undefined, oiWindowsSettings?: OiWindowsSettings | undefined, oiWindows?: OiWindows | undefined, context?: CumulVolContext | undefined) => number;
+export declare const getSpreadWithCumulVolPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, context: CumulVolContext) => number;
 /**
  * @dev Convenience function for calculating cumulative volume price impact
  * @dev Uses collateral and leverage instead of USD position size
@@ -103,6 +104,6 @@ export declare const getSpreadWithCumulVolPriceImpactP: (pairSpreadP: number, bu
 export declare const getCumulVolPriceImpact: (buy: boolean, collateral: number, leverage: number, open: boolean, context: CumulVolContext & {
     collateralPriceUsd: number;
 }) => number;
-export declare const getSpreadWithPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, pairDepth: PairDepth | undefined, oiWindowsSettings?: OiWindowsSettings | undefined, oiWindows?: OiWindows | undefined, context?: CumulVolContext | undefined) => number;
+export declare const getSpreadWithPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, context: CumulVolContext) => number;
 export { convertOiWindowsSettings, convertOiWindow, convertOiWindows, convertOiWindowsSettingsArray, } from "./converter";
 export { buildCumulVolContext } from "./builder";

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

@@ -73,6 +73,108 @@ 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) => {
+    console.log("tradeSizeUsd", tradeSizeUsd);
+    console.log("depthBandParams", 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;
+        console.log("bandDepthUsd", bandDepthUsd);
+        // Skip if band has same depth as previous (would cause division by zero)
+        if (bandDepthUsd <= prevBandDepthUsd) {
+            console.log("Skipping band");
+            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;
+        console.log("bandAvailableDepthUsd", bandAvailableDepthUsd);
+        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;
+            console.log("Consumed all remaining size");
+        }
+        else {
+            // Normal case: consume entire band and continue to next
+            depthConsumedUsd = bandAvailableDepthUsd;
+            remainingSizeUsd -= bandAvailableDepthUsd;
+            console.log("Consumed entire band");
+        }
+        // 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;
+        console.log("lowOffsetP", lowOffsetP);
+        console.log("offsetRangeP", offsetRangeP);
+        console.log("depthConsumedUsd", depthConsumedUsd);
+        console.log("bandAvailableDepthUsd", bandAvailableDepthUsd);
+        // Calculate average impact using trapezoidal rule: low + (range * fraction / 2)
+        const avgImpactP = lowOffsetP +
+            (offsetRangeP * depthConsumedUsd) / bandAvailableDepthUsd / 2;
+        console.log("avgImpactP", avgImpactP);
+        totalWeightedPriceImpactP += avgImpactP * depthConsumedUsd;
+        console.log("totalWeightedPriceImpactP", totalWeightedPriceImpactP);
+        // Update previous values for next iteration
+        topOfPrevBandOffsetPpm = topOfBandOffsetPpm;
+        prevBandDepthUsd = bandDepthUsd;
+    }
+    console.log("totalWeightedPriceImpactP", totalWeightedPriceImpactP);
+    console.log("tradeSizeUsd", tradeSizeUsd);
+    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;
+    console.log("effectiveCumulativeVolumeUsdUint", effectiveCumulativeVolumeUsdUint);
+    console.log("totalSizeLookupUsdUint", totalSizeLookupUsdUint);
+    const cumulativeVolPriceImpactP = _calculateDepthBandsPriceImpact(effectiveCumulativeVolumeUsdUint, depthBandParams);
+    const totalSizePriceImpactP = _calculateDepthBandsPriceImpact(totalSizeLookupUsdUint, depthBandParams);
+    console.log("cumulativeVolPriceImpactP", cumulativeVolPriceImpactP);
+    console.log("totalSizePriceImpactP", totalSizePriceImpactP);
+    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
@@ -86,7 +188,9 @@ exports.getLegacyFactor = getLegacyFactor;
  * @param context Additional context with depths, OI data, and factors
  * @returns Cumulative volume price impact percentage (not including spread)
  */
-const getTradeCumulVolPriceImpactP = (trader, pairIndex, long, tradeOpenInterestUsd, isPnlPositive, open, lastPosIncreaseBlock, context) => {
+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,
@@ -104,34 +208,43 @@ const getTradeCumulVolPriceImpactP = (trader, pairIndex, long, tradeOpenInterest
         (!open &&
             context?.exemptAfterProtectionCloseFactor === true &&
             (0, exports.isProtectionCloseFactorActive)(updatedContext) !== true)) {
+        console.log("No price impact, protection close factor");
         return 0;
     }
-    // Calculate trade skew direction (matches Solidity logic)
     const tradePositiveSkew = (long && open) || (!long && !open);
     const tradeSkewMultiplier = tradePositiveSkew ? 1 : -1;
-    // Select depth based on trade direction
-    // For positive skew (long open or short close), use depth above
-    // For negative skew (short open or long close), use depth below
-    const onePercentDepth = tradePositiveSkew
-        ? context.pairDepth?.onePercentDepthAboveUsd
-        : context.pairDepth?.onePercentDepthBelowUsd;
-    let activeOi = undefined;
-    if (context.oiWindowsSettings !== undefined) {
-        activeOi = (0, oiWindows_1.getActiveOi)((0, oiWindows_1.getCurrentOiWindowId)(context.oiWindowsSettings), context.oiWindowsSettings.windowsCount, context.oiWindows, open ? long : !long);
+    console.log("bands", context.pairDepthBands);
+    console.log("mapping", context.depthBandsMapping);
+    if (!context.pairDepthBands || !context.depthBandsMapping) {
+        console.log("No price impact, bands");
+        return 0;
     }
-    if (!onePercentDepth || activeOi === undefined) {
+    // 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) {
+        console.log("No price impact, depth bands");
         return 0;
     }
-    // Apply trade skew multiplier to match Solidity's signed calculation
+    // 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;
+    }
+    console.log("activeOi", activeOi);
     const signedActiveOi = activeOi * tradeSkewMultiplier;
     const signedTradeOi = tradeOpenInterestUsd * tradeSkewMultiplier;
-    // Calculate impact with proper signs (matching Solidity's _getTradePriceImpactP)
-    const finalPriceImpactP = ((signedActiveOi * (0, exports.getCumulativeFactor)(updatedContext) +
-        signedTradeOi / 2) /
-        onePercentDepth /
-        (0, exports.getLegacyFactor)(updatedContext)) *
-        (0, exports.getProtectionCloseFactor)(updatedContext);
-    return finalPriceImpactP;
+    console.log("signedActiveOi", signedActiveOi);
+    console.log("signedTradeOi", signedTradeOi);
+    // 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;
 /**
@@ -182,13 +295,12 @@ exports.getSpreadP = getSpreadP;
  * @param buy True for long, false for short
  * @param collateral Collateral amount
  * @param leverage Position leverage
- * @param pairDepth 1% depth values for the pair
  * @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, pairDepth, oiWindowsSettings, oiWindows, context) => {
+const getSpreadWithCumulVolPriceImpactP = (pairSpreadP, buy, collateral, leverage, context) => {
     if (pairSpreadP === undefined) {
         return 0;
     }
@@ -197,16 +309,7 @@ const getSpreadWithCumulVolPriceImpactP = (pairSpreadP, buy, collateral, leverag
     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,
-        pairDepth,
-        oiWindowsSettings,
-        oiWindows,
-    });
-    // If no depth or OI data, return just half spread
-    if (cumulVolImpact === 0 && (!pairDepth || !oiWindowsSettings)) {
-        return pairSpreadP / 2;
-    }
+    buy, positionSizeUsd, context?.isPnlPositive || false, context?.isOpen !== false, context?.createdBlock || 0, context);
     return baseSpread + cumulVolImpact;
 };
 exports.getSpreadWithCumulVolPriceImpactP = getSpreadWithCumulVolPriceImpactP;

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/open/index.js

@@ -23,14 +23,17 @@ const getTradeOpeningPriceImpact = (input, context) => {
     // Calculate fixed spread
     const spreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.long, true // opening
     );
+    console.log("spreadP", spreadP);
     // Calculate position size in USD
     const positionSizeUsd = positionSizeCollateral * context.collateralPriceUsd;
+    console.log("positionSizeUsd", positionSizeUsd);
     // 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);
+    console.log("cumulVolPriceImpactP", cumulVolPriceImpactP);
     // 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "1.4.5",
+  "version": "1.5.0-rc1",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [