@gainsnetwork/sdk 1.2.0 → 1.3.0-rc1

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

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

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

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

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

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

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

@@ -10,15 +10,16 @@ exports.buildCumulVolContext = void 0;
  * @returns Cumulative volume context ready for getTradeCumulVolPriceImpactP
  */
 const buildCumulVolContext = (globalTradingVariables, collateralIndex, pairIndex, additionalParams) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
     if (!collateral) {
         return undefined;
     }
     // Get pair-specific data from global variables
-    const pairDepth = (_a = globalTradingVariables.pairDepths) === null || _a === void 0 ? void 0 : _a[pairIndex];
-    const pairFactor = (_b = globalTradingVariables.pairFactors) === null || _b === void 0 ? void 0 : _b[pairIndex];
-    const oiWindows = (_c = globalTradingVariables.oiWindows) === null || _c === void 0 ? void 0 : _c[pairIndex];
+    // TODO: Update to use pairDepthBands for v10.2
+    const pairDepth = undefined; // globalTradingVariables.pairDepths?.[pairIndex];
+    const pairFactor = (_a = globalTradingVariables.pairFactors) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const oiWindows = (_b = globalTradingVariables.oiWindows) === null || _b === void 0 ? void 0 : _b[pairIndex];
     // Get OI windows settings (same for all pairs)
     // OI windows settings from global trading variables are already in SDK format
     const oiWindowsSettings = globalTradingVariables.oiWindowsSettings;
@@ -26,8 +27,8 @@ const buildCumulVolContext = (globalTradingVariables, collateralIndex, pairIndex
     const userPriceImpact = additionalParams.userPriceImpact;
     const protectionCloseFactorWhitelist = additionalParams.protectionCloseFactorWhitelist;
     // Get liquidation params - check both pair and group level
-    const liquidationParams = ((_e = (_d = globalTradingVariables.liquidationParams) === null || _d === void 0 ? void 0 : _d.pairs) === null || _e === void 0 ? void 0 : _e[pairIndex]) ||
-        ((_g = (_f = globalTradingVariables.liquidationParams) === null || _f === void 0 ? void 0 : _f.groups) === null || _g === void 0 ? void 0 : _g[0]); // fallback to first group
+    const liquidationParams = ((_d = (_c = globalTradingVariables.liquidationParams) === null || _c === void 0 ? void 0 : _c.pairs) === null || _d === void 0 ? void 0 : _d[pairIndex]) ||
+        ((_f = (_e = globalTradingVariables.liquidationParams) === null || _e === void 0 ? void 0 : _e.groups) === null || _f === void 0 ? void 0 : _f[0]); // fallback to first group
     return Object.assign({ 
         // Trade state
         isOpen: additionalParams.isOpen, isPnlPositive: additionalParams.isPnlPositive, createdBlock: additionalParams.createdBlock, 
@@ -38,6 +39,6 @@ const buildCumulVolContext = (globalTradingVariables, collateralIndex, pairIndex
         oiWindowsSettings,
         oiWindows,
         // User/collateral specific
-        userPriceImpact, collateralPriceUsd: ((_h = collateral.prices) === null || _h === void 0 ? void 0 : _h.collateralPriceUsd) || 1 }, pairFactor);
+        userPriceImpact, collateralPriceUsd: ((_g = collateral.prices) === null || _g === void 0 ? void 0 : _g.collateralPriceUsd) || 1 }, pairFactor);
 };
 exports.buildCumulVolContext = buildCumulVolContext;

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,6 +2,7 @@
  * @dev Cumulative volume price impact calculations
  * @dev Mirrors contract's getTradeCumulVolPriceImpactP functionality
  */
+import { PairDepthBands, DepthBandsMapping } from "./types";
 import { LiquidationParams, OiWindows, OiWindowsSettings, PairDepth, PairFactor, UserPriceImpact } from "../../types";
 import { ContractsVersion } from "../../../contracts/types";
 export type CumulVolContext = {
@@ -15,6 +16,8 @@ export type CumulVolContext = {
     pairDepth?: PairDepth | undefined;
     oiWindowsSettings?: OiWindowsSettings | undefined;
     oiWindows?: OiWindows | undefined;
+    pairDepthBands?: PairDepthBands | undefined;
+    depthBandsMapping?: DepthBandsMapping | undefined;
     userPriceImpact?: UserPriceImpact | undefined;
     collateralPriceUsd?: number;
 } & Partial<PairFactor>;

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

@@ -74,6 +74,89 @@ const getLegacyFactor = (context) => {
     return (context === null || context === void 0 ? void 0 : 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.pairSlot1.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.pairSlot1.bands[i]; // Already in 0-1 format
+        const topOfBandOffsetPpm = depthBandParams.mappingSlot1.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 (would revert in contract)
+    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
@@ -103,12 +186,32 @@ const getTradeCumulVolPriceImpactP = (trader, pairIndex, long, tradeOpenInterest
             (0, exports.isProtectionCloseFactorActive)(updatedContext) !== true)) {
         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
+    if (context.pairDepthBands && context.depthBandsMapping) {
+        // Select depth bands based on trade direction
+        const depthBands = tradePositiveSkew
+            ? context.pairDepthBands.above
+            : context.pairDepthBands.below;
+        if (depthBands && depthBands.totalDepthUsd > 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, {
+                pairSlot1: depthBands,
+                mappingSlot1: context.depthBandsMapping,
+            }, (0, exports.getProtectionCloseFactor)(updatedContext), (0, exports.getCumulativeFactor)(updatedContext));
+            return priceImpactP;
+        }
+        return 0;
+    }
+    // Fall back to legacy calculation for pre-v10.2 contracts
     const onePercentDepth = tradePositiveSkew
         ? (_a = context.pairDepth) === null || _a === void 0 ? void 0 : _a.onePercentDepthAboveUsd
         : (_b = context.pairDepth) === null || _b === void 0 ? void 0 : _b.onePercentDepthBelowUsd;

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/package.json

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