@gainsnetwork/sdk 0.0.0-v10.rc1 → 0.0.0-v10.rc3

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

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * @dev Converters for skew price impact data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSkewPriceImpactContexts = exports.convertSkewDepthsArray = exports.isValidSkewDepth = exports.createSkewPriceImpactContext = exports.createSkewDepth = exports.normalizeSkewDepth = exports.convertPairOiCollateralArray = exports.convertPairOiCollateral = exports.convertPairOiTokenArray = exports.convertPairOiToken = void 0;
+/**
+ * @dev Converts contract pair OI token data to SDK format
+ * @param contractData Contract pair OI token struct
+ * @returns Normalized pair OI token data
+ */
+const convertPairOiToken = (contractData) => {
+    // Token amounts are stored as 1e18 in contract
+    return {
+        oiLongToken: Number(contractData.oiLongToken) / 1e18,
+        oiShortToken: Number(contractData.oiShortToken) / 1e18,
+    };
+};
+exports.convertPairOiToken = convertPairOiToken;
+/**
+ * @dev Converts array of contract pair OI token data to SDK format
+ * @param contractDataArray Array of contract pair OI token data
+ * @returns Array of normalized pair OI token data
+ */
+const convertPairOiTokenArray = (contractDataArray) => {
+    return contractDataArray.map(exports.convertPairOiToken);
+};
+exports.convertPairOiTokenArray = convertPairOiTokenArray;
+/**
+ * @dev Converts contract pair OI collateral data to SDK format
+ * @param contractData Contract pair OI collateral struct
+ * @param collateralDecimals Number of decimals for the collateral (e.g., 18 for DAI, 6 for USDC)
+ * @returns Normalized pair OI collateral data
+ */
+const convertPairOiCollateral = (contractData, collateralDecimals) => {
+    const divisor = Math.pow(10, collateralDecimals);
+    return {
+        oiLongCollateral: Number(contractData.oiLongCollateral) / divisor,
+        oiShortCollateral: Number(contractData.oiShortCollateral) / divisor,
+    };
+};
+exports.convertPairOiCollateral = convertPairOiCollateral;
+/**
+ * @dev Converts array of contract pair OI collateral data to SDK format
+ * @param contractDataArray Array of contract pair OI collateral data
+ * @param collateralDecimals Array of collateral decimals for each entry
+ * @returns Array of normalized pair OI collateral data
+ */
+const convertPairOiCollateralArray = (contractDataArray, collateralDecimals) => {
+    if (contractDataArray.length !== collateralDecimals.length) {
+        throw new Error("Contract data array and collateral decimals array must have the same length");
+    }
+    return contractDataArray.map((data, index) => (0, exports.convertPairOiCollateral)(data, collateralDecimals[index]));
+};
+exports.convertPairOiCollateralArray = convertPairOiCollateralArray;
+/**
+ * @dev Normalizes skew depth from contract format
+ * @param depth Skew depth from contract (in collateral wei)
+ * @param collateralDecimals Number of decimals for the collateral
+ * @returns Normalized skew depth
+ */
+const normalizeSkewDepth = (depth, collateralDecimals) => {
+    const divisor = Math.pow(10, collateralDecimals);
+    return Number(depth) / divisor;
+};
+exports.normalizeSkewDepth = normalizeSkewDepth;
+/**
+ * @dev Creates a skew depth object
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param depth Normalized depth value
+ * @returns Skew depth object
+ */
+const createSkewDepth = (collateralIndex, pairIndex, depth) => {
+    return {
+        collateralIndex,
+        pairIndex,
+        depth,
+    };
+};
+exports.createSkewDepth = createSkewDepth;
+/**
+ * @dev Creates skew price impact context from arrays of data
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param skewDepths Array of normalized skew depths
+ * @param pairOiTokens Array of pair OI token data
+ * @returns Complete skew price impact context
+ */
+const createSkewPriceImpactContext = (collateralIndices, pairIndices, skewDepths, pairOiTokens) => {
+    if (collateralIndices.length !== pairIndices.length ||
+        pairIndices.length !== skewDepths.length ||
+        skewDepths.length !== pairOiTokens.length) {
+        throw new Error("All input arrays must have the same length");
+    }
+    const context = {
+        skewDepths: {},
+        pairOiTokens: {},
+    };
+    // Build nested objects indexed by collateralIndex and pairIndex
+    for (let i = 0; i < collateralIndices.length; i++) {
+        const collateralIndex = collateralIndices[i];
+        const pairIndex = pairIndices[i];
+        // Initialize collateral index objects if they don't exist
+        if (!context.skewDepths[collateralIndex]) {
+            context.skewDepths[collateralIndex] = {};
+        }
+        if (!context.pairOiTokens[collateralIndex]) {
+            context.pairOiTokens[collateralIndex] = {};
+        }
+        // Store data
+        context.skewDepths[collateralIndex][pairIndex] = skewDepths[i];
+        context.pairOiTokens[collateralIndex][pairIndex] = pairOiTokens[i];
+    }
+    return context;
+};
+exports.createSkewPriceImpactContext = createSkewPriceImpactContext;
+/**
+ * @dev Validates skew depth is within reasonable bounds
+ * @param depth Normalized skew depth
+ * @param minDepth Minimum allowed depth (default: 0)
+ * @param maxDepth Maximum allowed depth (default: 1e12)
+ * @returns Whether depth is valid
+ */
+const isValidSkewDepth = (depth, minDepth = 0, maxDepth = 1e12) => {
+    return depth >= minDepth && depth <= maxDepth;
+};
+exports.isValidSkewDepth = isValidSkewDepth;
+/**
+ * @dev Converts contract skew depths array to normalized values
+ * @param contractDepths Array of depths from contract
+ * @param collateralDecimals Array of decimals for each collateral
+ * @returns Array of normalized depths
+ */
+const convertSkewDepthsArray = (contractDepths, collateralDecimals) => {
+    if (contractDepths.length !== collateralDecimals.length) {
+        throw new Error("Contract depths array and collateral decimals array must have the same length");
+    }
+    return contractDepths.map((depth, index) => (0, exports.normalizeSkewDepth)(depth, collateralDecimals[index]));
+};
+exports.convertSkewDepthsArray = convertSkewDepthsArray;
+/**
+ * @dev Merges multiple contexts into one
+ * @param contexts Array of contexts to merge
+ * @returns Merged context
+ */
+const mergeSkewPriceImpactContexts = (contexts) => {
+    const merged = {
+        skewDepths: {},
+        pairOiTokens: {},
+    };
+    for (const context of contexts) {
+        // Merge skew depths
+        for (const collateralIndex in context.skewDepths) {
+            if (!merged.skewDepths[collateralIndex]) {
+                merged.skewDepths[collateralIndex] = {};
+            }
+            Object.assign(merged.skewDepths[collateralIndex], context.skewDepths[collateralIndex]);
+        }
+        // Merge pair OI tokens
+        for (const collateralIndex in context.pairOiTokens) {
+            if (!merged.pairOiTokens[collateralIndex]) {
+                merged.pairOiTokens[collateralIndex] = {};
+            }
+            Object.assign(merged.pairOiTokens[collateralIndex], context.pairOiTokens[collateralIndex]);
+        }
+    }
+    return merged;
+};
+exports.mergeSkewPriceImpactContexts = mergeSkewPriceImpactContexts;

package/lib/trade/priceImpact/skew/fetcher.d.ts

@@ -0,0 +1,63 @@
+import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
+import type { PairOiToken, SkewPriceImpactContext } from "..";
+/**
+ * @dev Fetches pair open interest in tokens for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @returns Promise resolving to pair OI in tokens
+ */
+export declare const fetchPairOiAfterV10Token: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number) => Promise<PairOiToken>;
+/**
+ * @dev Fetches pair open interest in tokens for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of pair OI in tokens
+ */
+export declare const fetchPairOisAfterV10Token: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<PairOiToken[]>;
+/**
+ * @dev Fetches skew depth for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param collateralDecimals Number of decimals for the collateral
+ * @returns Promise resolving to normalized skew depth
+ */
+export declare const fetchPairSkewDepth: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, collateralDecimals: number) => Promise<number>;
+/**
+ * @dev Fetches skew depths for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to array of normalized skew depths
+ */
+export declare const fetchPairSkewDepths: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[], collateralDecimals: number[]) => Promise<number[]>;
+/**
+ * @dev Fetches complete skew price impact context for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to complete skew price impact context
+ */
+export declare const fetchSkewPriceImpactContext: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[], collateralDecimals: number[]) => Promise<SkewPriceImpactContext>;
+/**
+ * @dev Fetches collateral decimals for given collateral indices
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @returns Promise resolving to array of decimals
+ */
+export declare const fetchCollateralDecimals: (contract: GNSMultiCollatDiamond, collateralIndices: number[]) => Promise<number[]>;
+/**
+ * @dev Calculates skew price impact for a trade using contract call
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param long Whether trade is long
+ * @param positionSizeToken Position size in tokens
+ * @param open Whether trade is opening
+ * @returns Promise resolving to price impact percentage (1e10)
+ */
+export declare const calculateTradeSkewPriceImpact: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, long: boolean, positionSizeToken: number, open: boolean) => Promise<number>;

package/lib/trade/priceImpact/skew/fetcher.js

@@ -0,0 +1,168 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTradeSkewPriceImpact = exports.fetchCollateralDecimals = exports.fetchSkewPriceImpactContext = exports.fetchPairSkewDepths = exports.fetchPairSkewDepth = exports.fetchPairOisAfterV10Token = exports.fetchPairOiAfterV10Token = void 0;
+const __1 = require("..");
+/**
+ * @dev Fetches pair open interest in tokens for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @returns Promise resolving to pair OI in tokens
+ */
+const fetchPairOiAfterV10Token = (contract, collateralIndex, pairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const contractData = yield contract.getPairOiAfterV10Token(collateralIndex, pairIndex);
+        return (0, __1.convertPairOiToken)(contractData);
+    }
+    catch (error) {
+        console.error("Error fetching pair OI token:", error);
+        throw error;
+    }
+});
+exports.fetchPairOiAfterV10Token = fetchPairOiAfterV10Token;
+/**
+ * @dev Fetches pair open interest in tokens for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of pair OI in tokens
+ */
+const fetchPairOisAfterV10Token = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("Collateral indices and pair indices arrays must have the same length");
+    }
+    try {
+        const contractDataArray = yield contract.getPairOisAfterV10Token(collateralIndices, pairIndices);
+        return contractDataArray.map(__1.convertPairOiToken);
+    }
+    catch (error) {
+        console.error("Error fetching pair OIs token:", error);
+        throw error;
+    }
+});
+exports.fetchPairOisAfterV10Token = fetchPairOisAfterV10Token;
+/**
+ * @dev Fetches skew depth for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param collateralDecimals Number of decimals for the collateral
+ * @returns Promise resolving to normalized skew depth
+ */
+const fetchPairSkewDepth = (contract, collateralIndex, pairIndex, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const contractDepth = yield contract.getPairSkewDepth(collateralIndex, pairIndex);
+        return (0, __1.normalizeSkewDepth)(contractDepth.toBigInt(), collateralDecimals);
+    }
+    catch (error) {
+        console.error("Error fetching skew depth:", error);
+        throw error;
+    }
+});
+exports.fetchPairSkewDepth = fetchPairSkewDepth;
+/**
+ * @dev Fetches skew depths for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to array of normalized skew depths
+ */
+const fetchPairSkewDepths = (contract, collateralIndices, pairIndices, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length ||
+        pairIndices.length !== collateralDecimals.length) {
+        throw new Error("All input arrays must have the same length");
+    }
+    try {
+        const contractDepths = yield contract.getPairSkewDepths(collateralIndices, pairIndices);
+        return contractDepths.map((depth, i) => (0, __1.normalizeSkewDepth)(depth.toBigInt(), collateralDecimals[i]));
+    }
+    catch (error) {
+        console.error("Error fetching skew depths:", error);
+        throw error;
+    }
+});
+exports.fetchPairSkewDepths = fetchPairSkewDepths;
+/**
+ * @dev Fetches complete skew price impact context for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to complete skew price impact context
+ */
+const fetchSkewPriceImpactContext = (contract, collateralIndices, pairIndices, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Fetch OI data and skew depths in parallel
+        const [pairOiTokens, skewDepths] = yield Promise.all([
+            (0, exports.fetchPairOisAfterV10Token)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairSkewDepths)(contract, collateralIndices, pairIndices, collateralDecimals),
+        ]);
+        return (0, __1.createSkewPriceImpactContext)(collateralIndices, pairIndices, skewDepths, pairOiTokens);
+    }
+    catch (error) {
+        console.error("Error fetching skew price impact context:", error);
+        throw error;
+    }
+});
+exports.fetchSkewPriceImpactContext = fetchSkewPriceImpactContext;
+/**
+ * @dev Fetches collateral decimals for given collateral indices
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @returns Promise resolving to array of decimals
+ */
+const fetchCollateralDecimals = (contract, collateralIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Get unique collateral indices to minimize calls
+        const uniqueIndices = [...new Set(collateralIndices)];
+        // Fetch collateral info for unique indices
+        const promises = uniqueIndices.map((index) => __awaiter(void 0, void 0, void 0, function* () {
+            const collateral = yield contract.getCollateral(index);
+            return { index, decimals: Number(collateral.precision) };
+        }));
+        const collateralData = yield Promise.all(promises);
+        // Create a map for quick lookup
+        const decimalsMap = new Map(collateralData.map(data => [data.index, data.decimals]));
+        // Return decimals in the same order as input
+        return collateralIndices.map(index => decimalsMap.get(index) || 18 // Default to 18 if not found
+        );
+    }
+    catch (error) {
+        console.error("Error fetching collateral decimals:", error);
+        throw error;
+    }
+});
+exports.fetchCollateralDecimals = fetchCollateralDecimals;
+/**
+ * @dev Calculates skew price impact for a trade using contract call
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param long Whether trade is long
+ * @param positionSizeToken Position size in tokens
+ * @param open Whether trade is opening
+ * @returns Promise resolving to price impact percentage (1e10)
+ */
+const calculateTradeSkewPriceImpact = (contract, collateralIndex, pairIndex, long, positionSizeToken, open) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const priceImpactP = yield contract.getTradeSkewPriceImpactP(collateralIndex, pairIndex, long, BigInt(Math.round(positionSizeToken * 1e18)), // Convert to 1e18 precision
+        open);
+        // Convert from int256 1e10 to percentage
+        return Number(priceImpactP) / 1e10;
+    }
+    catch (error) {
+        console.error("Error calculating trade skew price impact:", error);
+        throw error;
+    }
+});
+exports.calculateTradeSkewPriceImpact = calculateTradeSkewPriceImpact;

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

@@ -0,0 +1,58 @@
+/**
+ * @dev Skew price impact calculations for v10+ trades
+ * @dev Based on formula: (existingSkew + tradeSize/2) / skewDepth
+ */
+import { PairOiToken, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext, TradeSkewParams } from "./types";
+/**
+ * @dev Calculates net skew in tokens (long - short)
+ * @param pairOi Pair OI data with long and short token amounts
+ * @returns Net skew in tokens (positive = long heavy, negative = short heavy)
+ */
+export declare const getNetSkewToken: (pairOi: PairOiToken) => number;
+/**
+ * @dev Calculates net skew in collateral tokens
+ * @param netSkewToken Net skew in tokens
+ * @param currentPrice Current pair price
+ * @returns Net skew in collateral tokens
+ */
+export declare const getNetSkewCollateral: (netSkewToken: number, currentPrice: number) => number;
+/**
+ * @dev Determines trade direction impact on skew
+ * @param long Is long position
+ * @param open Is opening (true) or closing (false)
+ * @returns Whether trade increases or decreases skew
+ */
+export declare const getTradeSkewDirection: (long: boolean, open: boolean) => boolean;
+/**
+ * @dev Core skew price impact calculation
+ * @param existingSkewToken Current net skew in tokens (signed)
+ * @param tradeSizeToken Trade size in tokens (always positive)
+ * @param skewDepth Skew depth in collateral tokens
+ * @param tradeIncreasesSkew Whether trade increases skew in its direction
+ * @returns Price impact percentage (can be positive or negative)
+ */
+export declare const calculateSkewPriceImpactP: (existingSkewToken: number, tradeSizeToken: number, skewDepth: number, tradeIncreasesSkew: boolean) => number;
+/**
+ * @dev Main function to calculate skew price impact for a trade
+ * @param context Skew price impact context with depths and OI data
+ * @param input Trade parameters
+ * @returns Skew price impact result
+ */
+export declare const getTradeSkewPriceImpact: (context: SkewPriceImpactContext, input: SkewPriceImpactInput) => SkewPriceImpactResult;
+/**
+ * @dev Calculate skew price impact for a trade with all parameters
+ * @param params Trade parameters including price and version checks
+ * @param context Skew price impact context
+ * @returns Price impact percentage or 0 if not applicable
+ */
+export declare const getTradeSkewPriceImpactWithChecks: (params: TradeSkewParams, context: SkewPriceImpactContext) => number;
+/**
+ * @dev Calculate position sizes for partial operations
+ * @param originalSizeCollateral Original position size in collateral
+ * @param deltaCollateral Position size delta in collateral
+ * @param originalSizeToken Original position size in tokens
+ * @returns Delta in tokens proportional to collateral delta
+ */
+export declare const calculatePartialSizeToken: (originalSizeCollateral: number, deltaCollateral: number, originalSizeToken: number) => number;
+export * as SkewPriceImpact from "./types";
+export * from "./fetcher";

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

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * @dev Skew price impact calculations for v10+ trades
+ * @dev Based on formula: (existingSkew + tradeSize/2) / skewDepth
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpactWithChecks = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
+const utils_1 = require("../../utils");
+// Constants
+const PRICE_IMPACT_DIVIDER = 2; // Half price impact to match cumulative volume impact scale
+/**
+ * @dev Calculates net skew in tokens (long - short)
+ * @param pairOi Pair OI data with long and short token amounts
+ * @returns Net skew in tokens (positive = long heavy, negative = short heavy)
+ */
+const getNetSkewToken = (pairOi) => {
+    return pairOi.oiLongToken - pairOi.oiShortToken;
+};
+exports.getNetSkewToken = getNetSkewToken;
+/**
+ * @dev Calculates net skew in collateral tokens
+ * @param netSkewToken Net skew in tokens
+ * @param currentPrice Current pair price
+ * @returns Net skew in collateral tokens
+ */
+const getNetSkewCollateral = (netSkewToken, currentPrice) => {
+    return netSkewToken * currentPrice;
+};
+exports.getNetSkewCollateral = getNetSkewCollateral;
+/**
+ * @dev Determines trade direction impact on skew
+ * @param long Is long position
+ * @param open Is opening (true) or closing (false)
+ * @returns Whether trade increases or decreases skew
+ */
+const getTradeSkewDirection = (long, open) => {
+    // Opening long or closing short increases positive skew
+    // Opening short or closing long increases negative skew
+    return (long && open) || (!long && !open);
+};
+exports.getTradeSkewDirection = getTradeSkewDirection;
+/**
+ * @dev Core skew price impact calculation
+ * @param existingSkewToken Current net skew in tokens (signed)
+ * @param tradeSizeToken Trade size in tokens (always positive)
+ * @param skewDepth Skew depth in collateral tokens
+ * @param tradeIncreasesSkew Whether trade increases skew in its direction
+ * @returns Price impact percentage (can be positive or negative)
+ */
+const calculateSkewPriceImpactP = (existingSkewToken, tradeSizeToken, skewDepth, tradeIncreasesSkew) => {
+    if (skewDepth === 0) {
+        return 0; // No impact if depth is 0
+    }
+    // Convert signed values based on trade direction
+    const tradeSkewMultiplier = tradeIncreasesSkew ? 1 : -1;
+    const signedExistingSkew = existingSkewToken;
+    const signedTradeSize = tradeSizeToken * tradeSkewMultiplier;
+    // Formula: (existingSkew + tradeSize/2) / skewDepth
+    const numerator = signedExistingSkew + signedTradeSize / 2;
+    const priceImpactP = (numerator / skewDepth) * 100; // Convert to percentage
+    // Apply divider to match cumulative volume impact scale
+    return priceImpactP / PRICE_IMPACT_DIVIDER;
+};
+exports.calculateSkewPriceImpactP = calculateSkewPriceImpactP;
+/**
+ * @dev Main function to calculate skew price impact for a trade
+ * @param context Skew price impact context with depths and OI data
+ * @param input Trade parameters
+ * @returns Skew price impact result
+ */
+const getTradeSkewPriceImpact = (context, input) => {
+    var _a, _b;
+    // Get skew depth for the pair
+    const skewDepth = (_a = context.skewDepths[input.collateralIndex]) === null || _a === void 0 ? void 0 : _a[input.pairIndex];
+    if (skewDepth === undefined) {
+        throw new Error(`Missing skew depth for collateral ${input.collateralIndex} pair ${input.pairIndex}`);
+    }
+    // Get pair OI data
+    const pairOi = (_b = context.pairOiTokens[input.collateralIndex]) === null || _b === void 0 ? void 0 : _b[input.pairIndex];
+    if (!pairOi) {
+        throw new Error(`Missing pair OI data for collateral ${input.collateralIndex} pair ${input.pairIndex}`);
+    }
+    // Calculate net skew
+    const netSkewToken = (0, exports.getNetSkewToken)(pairOi);
+    // Determine trade direction impact
+    const tradeIncreasesSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
+    // Calculate price impact
+    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradeIncreasesSkew);
+    // Determine trade direction relative to skew
+    let tradeDirection;
+    if (priceImpactP > 0) {
+        tradeDirection = "increase";
+    }
+    else if (priceImpactP < 0) {
+        tradeDirection = "decrease";
+    }
+    else {
+        tradeDirection = "neutral";
+    }
+    return {
+        priceImpactP,
+        netSkewToken,
+        netSkewCollateral: 0,
+        tradeDirection,
+    };
+};
+exports.getTradeSkewPriceImpact = getTradeSkewPriceImpact;
+/**
+ * @dev Calculate skew price impact for a trade with all parameters
+ * @param params Trade parameters including price and version checks
+ * @param context Skew price impact context
+ * @returns Price impact percentage or 0 if not applicable
+ */
+const getTradeSkewPriceImpactWithChecks = (params, context) => {
+    // v10+ trades only
+    if (params.contractsVersion < 10) {
+        return 0;
+    }
+    // Counter trades don't pay skew impact
+    if (params.isCounterTrade) {
+        return 0;
+    }
+    // Calculate position size in tokens
+    const positionSizeToken = (0, utils_1.calculatePositionSizeToken)(params.positionSizeCollateral, params.currentPrice);
+    // Get skew price impact
+    const result = (0, exports.getTradeSkewPriceImpact)(context, {
+        collateralIndex: params.collateralIndex,
+        pairIndex: params.pairIndex,
+        long: params.long,
+        open: params.open,
+        positionSizeToken,
+    });
+    return result.priceImpactP;
+};
+exports.getTradeSkewPriceImpactWithChecks = getTradeSkewPriceImpactWithChecks;
+/**
+ * @dev Calculate position sizes for partial operations
+ * @param originalSizeCollateral Original position size in collateral
+ * @param deltaCollateral Position size delta in collateral
+ * @param originalSizeToken Original position size in tokens
+ * @returns Delta in tokens proportional to collateral delta
+ */
+const calculatePartialSizeToken = (originalSizeCollateral, deltaCollateral, originalSizeToken) => {
+    if (originalSizeCollateral === 0) {
+        return 0;
+    }
+    // For partial close/add, token delta is proportional to collateral delta
+    return (deltaCollateral * originalSizeToken) / originalSizeCollateral;
+};
+exports.calculatePartialSizeToken = calculatePartialSizeToken;
+// Export namespace for types
+exports.SkewPriceImpact = __importStar(require("./types"));
+__exportStar(require("./fetcher"), exports);