@gainsnetwork/sdk 1.1.1-rc1 → 1.3.0-rc1

package/lib/contracts/utils/pairs.d.ts

@@ -1,7 +1,18 @@
-import { Pair, Fee, OpenInterest, PairDepth, PairIndex } from "../../trade/types";
+import { Pair, Fee, OpenInterest, PairIndex } from "../../trade/types";
 import { Contracts } from "../../contracts/types";
 export declare const fetchPairs: (contracts: Contracts, pairIxs: PairIndex[]) => Promise<Pair[]>;
-export declare const fetchPairDepths: (contracts: Contracts, pairIxs: number[]) => Promise<PairDepth[]>;
+export declare const fetchPairDepthBands: (contracts: Contracts, pairIxs: number[]) => Promise<any[]>;
+export declare const fetchPairDepthBandsDecoded: (contracts: Contracts, pairIxs: number[]) => Promise<{
+    totalDepthAboveUsd: number[];
+    totalDepthBelowUsd: number[];
+    bandsAbove: number[][];
+    bandsBelow: number[][];
+}>;
+export declare const fetchDepthBandsMapping: (contracts: Contracts) => Promise<{
+    slot1: string;
+    slot2: string;
+}>;
+export declare const fetchDepthBandsMappingDecoded: (contracts: Contracts) => Promise<number[]>;
 export declare const fetchFees: (contracts: Contracts, feeIxs: PairIndex[]) => Promise<Fee[]>;
 export declare const fetchOpenInterest: (contracts: Contracts, collateralIndex: number, pairIxs: number[]) => Promise<OpenInterest[]>;
 export declare const getPairDescription: (pairIndex: PairIndex) => string;

package/lib/contracts/utils/pairs.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchPairDepths = exports.fetchPairs = void 0;
+exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchDepthBandsMappingDecoded = exports.fetchDepthBandsMapping = exports.fetchPairDepthBandsDecoded = exports.fetchPairDepthBands = exports.fetchPairs = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
@@ -40,26 +40,85 @@ const fetchPairs = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, fun
     }
 });
 exports.fetchPairs = fetchPairs;
-const fetchPairDepths = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchPairDepthBands = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts || pairIxs.length === 0) {
+        return [];
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns array of PairDepthBands structs (encoded slots)
+        // Using quoted signature for overloaded function
+        const depthBands = yield multiCollatContract["getPairDepthBands(uint256[])"](pairIxs);
+        return depthBands;
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pair depth bands!`);
+        throw error;
+    }
+});
+exports.fetchPairDepthBands = fetchPairDepthBands;
+const fetchPairDepthBandsDecoded = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts || pairIxs.length === 0) {
+        return {
+            totalDepthAboveUsd: [],
+            totalDepthBelowUsd: [],
+            bandsAbove: [],
+            bandsBelow: [],
+        };
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns decoded values
+        // Using quoted signature for overloaded function
+        const [totalDepthAboveUsd, totalDepthBelowUsd, bandsAbove, bandsBelow] = yield multiCollatContract["getPairDepthBandsDecoded(uint256[])"](pairIxs);
+        return {
+            totalDepthAboveUsd: totalDepthAboveUsd.map((v) => parseFloat(v.toString())),
+            totalDepthBelowUsd: totalDepthBelowUsd.map((v) => parseFloat(v.toString())),
+            bandsAbove: bandsAbove.map((bands) => bands.map((b) => parseInt(b.toString()))),
+            bandsBelow: bandsBelow.map((bands) => bands.map((b) => parseInt(b.toString()))),
+        };
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching decoded pair depth bands!`);
+        throw error;
+    }
+});
+exports.fetchPairDepthBandsDecoded = fetchPairDepthBandsDecoded;
+const fetchDepthBandsMapping = (contracts) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return { slot1: "0", slot2: "0" };
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns two uint256 slots
+        const [slot1, slot2] = yield multiCollatContract.getDepthBandsMapping();
+        return {
+            slot1: slot1.toString(),
+            slot2: slot2.toString(),
+        };
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching depth bands mapping!`);
+        throw error;
+    }
+});
+exports.fetchDepthBandsMapping = fetchDepthBandsMapping;
+const fetchDepthBandsMappingDecoded = (contracts) => __awaiter(void 0, void 0, void 0, function* () {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const pairParams = yield multiCollatContract.getPairDepths(pairIxs);
-        return pairParams.map(pair => {
-            return {
-                onePercentDepthAboveUsd: parseFloat(pair.onePercentDepthAboveUsd.toString()),
-                onePercentDepthBelowUsd: parseFloat(pair.onePercentDepthBelowUsd.toString()),
-            };
-        });
+        // Returns array of 30 uint16 values
+        const bands = yield multiCollatContract.getDepthBandsMappingDecoded();
+        return bands.map((b) => parseInt(b.toString()));
     }
     catch (error) {
-        console.error(`Unexpected error while fetching pairs!`);
+        console.error(`Unexpected error while fetching decoded depth bands mapping!`);
         throw error;
     }
 });
-exports.fetchPairDepths = fetchPairDepths;
+exports.fetchDepthBandsMappingDecoded = fetchDepthBandsMappingDecoded;
 const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, function* () {
     if (!contracts) {
         return [];

package/lib/index.d.ts

@@ -5,5 +5,6 @@ export * from "./constants";
 export * from "./utils";
 export * from "./vault";
 export * from "./backend";
+export * from "./pricing";
 export * from "./trade/fees/borrowing/index";
 export { ContractsVersion } from "./contracts/types";

package/lib/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./backend"), exports);
+__exportStar(require("./pricing"), exports);
 // Not sure why this is needed, but it is. Barrel imports are not working.
 __exportStar(require("./trade/fees/borrowing/index"), exports);
 // Export ContractsVersion for frontend usage

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

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