@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc2

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Types for trade opening price impact calculations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,12 @@
+/**
+ * @dev Builders for skew price impact contexts
+ */
+import { TradingVariablesCollateral } from "../../../backend/tradingVariables/types";
+import { SkewPriceImpactContext } from "./types";
+/**
+ * @dev Builds skew price impact context from trading variables for a specific pair
+ * @param tradingVariables Trading variables containing collateral data
+ * @param pairIndex Index of the pair to build context for
+ * @returns Skew price impact context for the pair
+ */
+export declare const buildSkewPriceImpactContext: (tradingVariables: TradingVariablesCollateral, pairIndex: number) => SkewPriceImpactContext;

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

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @dev Builders for skew price impact contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSkewPriceImpactContext = void 0;
+/**
+ * @dev Builds skew price impact context from trading variables for a specific pair
+ * @param tradingVariables Trading variables containing collateral data
+ * @param pairIndex Index of the pair to build context for
+ * @returns Skew price impact context for the pair
+ */
+const buildSkewPriceImpactContext = (tradingVariables, pairIndex) => {
+    var _a, _b, _c;
+    const skewDepth = (_b = (_a = tradingVariables.pairSkewDepths) === null || _a === void 0 ? void 0 : _a[pairIndex]) !== null && _b !== void 0 ? _b : 0;
+    const pairOi = (_c = tradingVariables.pairOis) === null || _c === void 0 ? void 0 : _c[pairIndex];
+    if (!pairOi) {
+        throw new Error(`Pair OI data not found for pair index ${pairIndex}`);
+    }
+    return {
+        skewDepth,
+        pairOiToken: {
+            oiLongToken: pairOi.token.long,
+            oiShortToken: pairOi.token.short,
+        },
+    };
+};
+exports.buildSkewPriceImpactContext = buildSkewPriceImpactContext;

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

@@ -0,0 +1,46 @@
+/**
+ * @dev Converters for skew price impact data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+import { IPriceImpact } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { PairOiToken, PairOiCollateral } from "./types";
+/**
+ * @dev Converts contract pair OI token data to SDK format
+ * @param contractData Contract pair OI token struct
+ * @returns Normalized pair OI token data
+ */
+export declare const convertPairOiToken: (contractData: IPriceImpact.PairOiTokenStruct) => PairOiToken;
+/**
+ * @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
+ */
+export declare const convertPairOiTokenArray: (contractDataArray: IPriceImpact.PairOiTokenStruct[]) => PairOiToken[];
+/**
+ * @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
+ */
+export declare const convertPairOiCollateral: (contractData: IPriceImpact.PairOiCollateralStruct, collateralDecimals: number) => PairOiCollateral;
+/**
+ * @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
+ */
+export declare const convertPairOiCollateralArray: (contractDataArray: IPriceImpact.PairOiCollateralStruct[], collateralDecimals: number[]) => PairOiCollateral[];
+/**
+ * @dev Converts skew depth from contract format to SDK format
+ * @param depth Skew depth from contract (in token units with 1e18 precision)
+ * @returns Normalized skew depth in tokens
+ */
+export declare const convertSkewDepth: (depth: string) => number;
+/**
+ * @dev Converts array of skew depths from contract format to SDK format
+ * @param depths Array of skew depths from contract (in token units with 1e18 precision)
+ * @returns Object mapping pair index to normalized depth
+ */
+export declare const convertPairSkewDepths: (depths: string[]) => {
+    [pairIndex: number]: number;
+};

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

@@ -0,0 +1,81 @@
+"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.convertPairSkewDepths = exports.convertSkewDepth = 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 Converts skew depth from contract format to SDK format
+ * @param depth Skew depth from contract (in token units with 1e18 precision)
+ * @returns Normalized skew depth in tokens
+ */
+const convertSkewDepth = (depth) => {
+    // Token depths are always stored with 1e18 precision in the contract
+    return Number(depth) / 1e18;
+};
+exports.convertSkewDepth = convertSkewDepth;
+/**
+ * @dev Converts array of skew depths from contract format to SDK format
+ * @param depths Array of skew depths from contract (in token units with 1e18 precision)
+ * @returns Object mapping pair index to normalized depth
+ */
+const convertPairSkewDepths = (depths) => {
+    const result = {};
+    depths.forEach((depth, index) => {
+        if (depth && depth !== "0") {
+            result[index] = (0, exports.convertSkewDepth)(depth);
+        }
+    });
+    return result;
+};
+exports.convertPairSkewDepths = convertPairSkewDepths;

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

@@ -0,0 +1,60 @@
+import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
+import type { PairOiToken, SkewPriceImpactContext } from "./types";
+/**
+ * @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
+ * @returns Promise resolving to normalized skew depth
+ */
+export declare const fetchPairSkewDepth: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: 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
+ * @returns Promise resolving to array of normalized skew depths
+ */
+export declare const fetchPairSkewDepths: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<number[]>;
+/**
+ * @dev Fetches skew price impact context for a single pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @returns Promise resolving to skew price impact context
+ */
+export declare const fetchSkewPriceImpactContext: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: 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,169 @@
+"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 converter_1 = require("./converter");
+/**
+ * @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, converter_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(converter_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
+ * @returns Promise resolving to normalized skew depth
+ */
+const fetchPairSkewDepth = (contract, collateralIndex, pairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const contractDepth = yield contract.getPairSkewDepth(collateralIndex, pairIndex);
+        // Token depths are always 1e18 precision
+        return (0, converter_1.convertSkewDepth)(contractDepth.toString());
+    }
+    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
+ * @returns Promise resolving to array of normalized skew depths
+ */
+const fetchPairSkewDepths = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("All input arrays must have the same length");
+    }
+    try {
+        const contractDepths = yield contract.getPairSkewDepths(collateralIndices, pairIndices);
+        // Token depths are always 1e18 precision
+        return contractDepths.map(depth => (0, converter_1.convertSkewDepth)(depth.toString()));
+    }
+    catch (error) {
+        console.error("Error fetching skew depths:", error);
+        throw error;
+    }
+});
+exports.fetchPairSkewDepths = fetchPairSkewDepths;
+/**
+ * @dev Fetches skew price impact context for a single pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @returns Promise resolving to skew price impact context
+ */
+const fetchSkewPriceImpactContext = (contract, collateralIndex, pairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Fetch OI data and skew depth in parallel
+        const [pairOiToken, skewDepth] = yield Promise.all([
+            (0, exports.fetchPairOiAfterV10Token)(contract, collateralIndex, pairIndex),
+            (0, exports.fetchPairSkewDepth)(contract, collateralIndex, pairIndex),
+        ]);
+        return {
+            skewDepth,
+            pairOiToken,
+        };
+    }
+    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,53 @@
+/**
+ * @dev Skew price impact calculations for v10+ trades
+ * @dev Based on formula: (existingSkew + tradeSize/2) / skewDepth
+ */
+import { PairOiToken, SkewPriceImpactInput, SkewPriceImpactResult, SkewPriceImpactContext } 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
+ * @param netSkewToken Net skew in tokens
+ * @param currentPrice Current pair price
+ * @returns Net skew in collateral
+ */
+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 tokens
+ * @param tradePositiveSkew 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, tradePositiveSkew: boolean) => number;
+/**
+ * @dev Main function to calculate skew price impact for a trade
+ * @param input Trade parameters
+ * @param context Skew price impact context with depths and OI data
+ * @returns Skew price impact result
+ */
+export declare const getTradeSkewPriceImpact: (input: SkewPriceImpactInput, context: SkewPriceImpactContext) => SkewPriceImpactResult;
+/**
+ * @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 "./converter";
+export * from "./builder";
+export * from "./fetcher";