@gainsnetwork/sdk 0.0.0-me-rc1

package/lib/markets/oi/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @dev Main export file for OI module
+ * @dev Provides unified Open Interest management functionality
+ */
+import { GenericPairOiContext } from "./types";
+export declare const getPairTotalOisCollateral: (pairIndex: number, context: GenericPairOiContext) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for long and short sides in collateral precision
+ */
+export declare const getPairTotalOisDynamicCollateral: (pairIndex: number, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens on one side only
+ * @param pairIndex index of pair
+ * @param long true if long, false if short
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for the specified side in collateral precision
+ */
+export declare const getPairTotalOiDynamicCollateral: (pairIndex: number, long: boolean, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => number;
+/**
+ * @dev Returns pair open interest skew (v10 only) in tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array
+ * @returns skew in token amount (positive = more longs, negative = more shorts)
+ */
+export declare const getPairV10OiTokenSkewCollateral: (pairIndex: number, context: GenericPairOiContext) => number;
+/**
+ * @dev Returns pair dynamic skew (v10 only) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic skew in collateral precision
+ */
+export declare const getPairV10OiDynamicSkewCollateral: (pairIndex: number, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => number;
+export { UnifiedPairOi, GroupOi, ComputedOi } from "./types";
+export { convertBeforeV10Collateral, convertCollateralOi, convertTokenOi, convertPairOi, convertPairOiArray, computeOiValues, } from "./converter";

package/lib/markets/oi/index.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * @dev Main export file for OI module
+ * @dev Provides unified Open Interest management functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = exports.getPairV10OiDynamicSkewCollateral = exports.getPairV10OiTokenSkewCollateral = exports.getPairTotalOiDynamicCollateral = exports.getPairTotalOisDynamicCollateral = exports.getPairTotalOisCollateral = void 0;
+const getPairTotalOisCollateral = (pairIndex, context) => {
+    return {
+        long: context.pairOis[pairIndex].beforeV10Collateral.long +
+            context.pairOis[pairIndex].collateral.long,
+        short: context.pairOis[pairIndex].beforeV10Collateral.short +
+            context.pairOis[pairIndex].collateral.short,
+    };
+};
+exports.getPairTotalOisCollateral = getPairTotalOisCollateral;
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for long and short sides in collateral precision
+ */
+const getPairTotalOisDynamicCollateral = (pairIndex, context) => {
+    const pairOi = context.pairOis[pairIndex];
+    // We have to use the initial collateral OIs for pre-v10 trades because we don't have OIs in token amount
+    const oiLongCollateralDynamicAfterV10 = pairOi.beforeV10Collateral.long +
+        pairOi.token.long * context.currentPairPrice;
+    const oiShortCollateralDynamicAfterV10 = pairOi.beforeV10Collateral.short +
+        pairOi.token.short * context.currentPairPrice;
+    return {
+        long: oiLongCollateralDynamicAfterV10,
+        short: oiShortCollateralDynamicAfterV10,
+    };
+};
+exports.getPairTotalOisDynamicCollateral = getPairTotalOisDynamicCollateral;
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens on one side only
+ * @param pairIndex index of pair
+ * @param long true if long, false if short
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for the specified side in collateral precision
+ */
+const getPairTotalOiDynamicCollateral = (pairIndex, long, context) => {
+    const dynamicOis = (0, exports.getPairTotalOisDynamicCollateral)(pairIndex, context);
+    return long ? dynamicOis.long : dynamicOis.short;
+};
+exports.getPairTotalOiDynamicCollateral = getPairTotalOiDynamicCollateral;
+/**
+ * @dev Returns pair open interest skew (v10 only) in tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array
+ * @returns skew in token amount (positive = more longs, negative = more shorts)
+ */
+const getPairV10OiTokenSkewCollateral = (pairIndex, context) => {
+    const pairOi = context.pairOis[pairIndex];
+    return pairOi.token.long - pairOi.token.short;
+};
+exports.getPairV10OiTokenSkewCollateral = getPairV10OiTokenSkewCollateral;
+/**
+ * @dev Returns pair dynamic skew (v10 only) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic skew in collateral precision
+ */
+const getPairV10OiDynamicSkewCollateral = (pairIndex, context) => {
+    return ((0, exports.getPairV10OiTokenSkewCollateral)(pairIndex, context) *
+        context.currentPairPrice);
+};
+exports.getPairV10OiDynamicSkewCollateral = getPairV10OiDynamicSkewCollateral;
+// Converters
+var converter_1 = require("./converter");
+Object.defineProperty(exports, "convertBeforeV10Collateral", { enumerable: true, get: function () { return converter_1.convertBeforeV10Collateral; } });
+Object.defineProperty(exports, "convertCollateralOi", { enumerable: true, get: function () { return converter_1.convertCollateralOi; } });
+Object.defineProperty(exports, "convertTokenOi", { enumerable: true, get: function () { return converter_1.convertTokenOi; } });
+Object.defineProperty(exports, "convertPairOi", { enumerable: true, get: function () { return converter_1.convertPairOi; } });
+Object.defineProperty(exports, "convertPairOiArray", { enumerable: true, get: function () { return converter_1.convertPairOiArray; } });
+Object.defineProperty(exports, "computeOiValues", { enumerable: true, get: function () { return converter_1.computeOiValues; } });

package/lib/markets/oi/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @dev Consolidated OI types for unified Open Interest management
+ * @dev Represents the three OI storage systems in Gains Network v10
+ */
+/**
+ * @dev Unified pair OI structure combining all storage systems
+ */
+export interface UnifiedPairOi {
+    /**
+     * @dev Maximum allowed OI in collateral (applies to combined OI)
+     */
+    maxCollateral: number;
+    /**
+     * @dev Pre-v10 trades OI stored in collateral amounts
+     * @dev Static values from when positions were opened
+     */
+    beforeV10Collateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev Post-v10 trades OI stored in collateral amounts
+     * @dev Initial collateral values when positions were opened
+     * @dev Used for administrative operations and static calculations
+     */
+    collateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev Post-v10 trades OI stored in token amounts
+     * @dev Used for dynamic calculations (multiply by current price)
+     * @dev Powers skew impact and funding fees
+     */
+    token: {
+        long: number;
+        short: number;
+    };
+}
+export type GenericPairOiContext = {
+    pairOis: UnifiedPairOi[];
+};
+/**
+ * @dev Group OI remains unchanged - only used by borrowing v1
+ * @dev Re-export existing type for consistency
+ */
+export { OpenInterest as GroupOi } from "../../trade/types";
+/**
+ * @dev Helper type for computed OI values
+ */
+export interface ComputedOi {
+    /**
+     * @dev Total OI using static values: beforeV10Collateral + collateral
+     * @dev Used for administrative operations
+     */
+    totalStaticCollateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev Total OI using dynamic values: beforeV10Collateral + (token * price)
+     * @dev Used for real-time calculations like fees
+     */
+    totalDynamicCollateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev v10-only OI using static collateral values
+     * @dev Used for funding fee markets display
+     */
+    v10StaticCollateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev v10-only OI using dynamic values: token * price
+     * @dev Used for funding fee markets real-time display
+     */
+    v10DynamicCollateral: {
+        long: number;
+        short: number;
+    };
+    /**
+     * @dev Net skew in tokens (v10+ only)
+     * @dev Positive = more longs, negative = more shorts
+     */
+    skewToken: number;
+}

package/lib/markets/oi/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @dev Consolidated OI types for unified Open Interest management
+ * @dev Represents the three OI storage systems in Gains Network v10
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/markets/price/builder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @dev Builder functions for creating market price contexts
+ */
+import { MarketPriceContext } from "./types";
+import { TradingVariablesCollateral } from "../../backend/tradingVariables/types";
+/**
+ * @dev Builds a market price context for a specific pair from trading variables
+ * @param tradingVariables Trading variables for a specific collateral
+ * @param pairIndex Pair index to create context for
+ * @returns Market price context for the pair
+ */
+export declare const buildMarketPriceContext: (tradingVariables: TradingVariablesCollateral, pairIndex: number) => MarketPriceContext;
+/**
+ * @dev Creates an empty market price context
+ * @returns Empty market price context
+ */
+export declare const createEmptyMarketPriceContext: () => MarketPriceContext;
+/**
+ * @dev Creates a market price context with custom values
+ * @param skewDepth Skew depth in tokens
+ * @param oiLongToken Long OI in tokens
+ * @param oiShortToken Short OI in tokens
+ * @returns Market price context
+ */
+export declare const createMarketPriceContext: (skewDepth: number, oiLongToken: number, oiShortToken: number) => MarketPriceContext;

package/lib/markets/price/builder.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * @dev Builder functions for creating market price contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMarketPriceContext = exports.createEmptyMarketPriceContext = exports.buildMarketPriceContext = void 0;
+/**
+ * @dev Builds a market price context for a specific pair from trading variables
+ * @param tradingVariables Trading variables for a specific collateral
+ * @param pairIndex Pair index to create context for
+ * @returns Market price context for the pair
+ */
+const buildMarketPriceContext = (tradingVariables, pairIndex) => {
+    // Get skew depth for the pair, default to 0 if not set
+    const skewDepth = tradingVariables.pairSkewDepths[pairIndex] || 0;
+    // Get pair OI data
+    const pairOi = tradingVariables.pairOis[pairIndex];
+    if (!pairOi) {
+        // Return default context if no OI data
+        return {
+            skewDepth,
+            pairOiToken: {
+                oiLongToken: 0,
+                oiShortToken: 0,
+            },
+        };
+    }
+    // Extract token OI from unified pair OI
+    const pairOiToken = {
+        oiLongToken: pairOi.token.long,
+        oiShortToken: pairOi.token.short,
+    };
+    return {
+        skewDepth,
+        pairOiToken,
+    };
+};
+exports.buildMarketPriceContext = buildMarketPriceContext;
+/**
+ * @dev Creates an empty market price context
+ * @returns Empty market price context
+ */
+const createEmptyMarketPriceContext = () => {
+    return {
+        skewDepth: 0,
+        pairOiToken: {
+            oiLongToken: 0,
+            oiShortToken: 0,
+        },
+    };
+};
+exports.createEmptyMarketPriceContext = createEmptyMarketPriceContext;
+/**
+ * @dev Creates a market price context with custom values
+ * @param skewDepth Skew depth in tokens
+ * @param oiLongToken Long OI in tokens
+ * @param oiShortToken Short OI in tokens
+ * @returns Market price context
+ */
+const createMarketPriceContext = (skewDepth, oiLongToken, oiShortToken) => {
+    return {
+        skewDepth,
+        pairOiToken: {
+            oiLongToken,
+            oiShortToken,
+        },
+    };
+};
+exports.createMarketPriceContext = createMarketPriceContext;

package/lib/markets/price/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @dev Market price module exports
+ */
+export * from "./types";
+export * from "./marketPrice";
+export * from "./builder";
+export * from "./signedPrices";

package/lib/markets/price/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @dev Market price module exports
+ */
+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 __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 });
+__exportStar(require("./types"), exports);
+__exportStar(require("./marketPrice"), exports);
+__exportStar(require("./builder"), exports);
+__exportStar(require("./signedPrices"), exports);

package/lib/markets/price/marketPrice.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @dev Current market price calculation with skew impact
+ */
+import { MarketPriceResult, MarketPriceContext } from "./types";
+/**
+ * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
+ * @param pairIndex Trading pair index
+ * @param oraclePrice Oracle price for the pair
+ * @param context Market price context with depths and OI data
+ * @returns Current market price with skew impact applied
+ */
+export declare const getCurrentMarketPrice: (pairIndex: number, oraclePrice: number, context: MarketPriceContext) => MarketPriceResult;

package/lib/markets/price/marketPrice.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @dev Current market price calculation with skew impact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentMarketPrice = void 0;
+const skew_1 = require("../../trade/priceImpact/skew");
+/**
+ * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
+ * @param pairIndex Trading pair index
+ * @param oraclePrice Oracle price for the pair
+ * @param context Market price context with depths and OI data
+ * @returns Current market price with skew impact applied
+ */
+const getCurrentMarketPrice = (pairIndex, oraclePrice, context) => {
+    let skewImpactP = 0;
+    if (context.skewDepth > 0) {
+        const skewResult = (0, skew_1.getTradeSkewPriceImpact)({
+            collateralIndex: 0,
+            pairIndex,
+            long: true,
+            open: true,
+            positionSizeToken: 0, // Size 0 for current market price
+        }, context);
+        skewImpactP = skewResult.basePriceImpactP;
+    }
+    const marketPrice = oraclePrice * (1 + skewImpactP / 100);
+    return {
+        marketPrice,
+        skewImpactP,
+        oraclePrice,
+    };
+};
+exports.getCurrentMarketPrice = getCurrentMarketPrice;

package/lib/markets/price/signedPrices.d.ts

@@ -0,0 +1,36 @@
+import { Oracle, SignedPricesResponse } from "./types";
+import { PendingOrderType } from "../../trade";
+export interface FetchSignedPricesInput {
+    oracles: Oracle[];
+    pairs: number[];
+    chain: number;
+    minAnswer?: number;
+    timeoutMs?: number;
+}
+export declare const fetchSignedPrices: (input: FetchSignedPricesInput) => Promise<SignedPricesResponse[] | null>;
+export interface FetchSignedLookbackPricesInput {
+    oracles: Oracle[];
+    trader: string;
+    tradeIndex: number;
+    pair: number;
+    orderType: PendingOrderType;
+    currentBlock: number;
+    fromBlock: number;
+    chain: number;
+    minAnswer?: number;
+    timeoutMs?: number;
+}
+export declare const fetchSignedLookbackPrices: (input: FetchSignedLookbackPricesInput) => Promise<SignedPricesResponse[] | null>;
+export interface RetryOptions {
+    maxRetries?: number;
+    retryDelayMs?: number;
+    backoffMultiplier?: number;
+}
+export declare const fetchSignedPricesWithRetry: (input: FetchSignedPricesInput, retryOptions?: RetryOptions) => Promise<SignedPricesResponse[] | null>;
+export declare const fetchSignedLookbackPricesWithRetry: (input: FetchSignedLookbackPricesInput, retryOptions?: RetryOptions) => Promise<SignedPricesResponse[] | null>;
+export declare const validateSignedPricesPairs: (pairs: number[]) => {
+    valid: boolean;
+    pairs: number[];
+};
+export declare const isValidSignedPricesChain: (chainId: number) => boolean;
+export declare const isValidSignedPricesOrderType: (orderType: PendingOrderType) => boolean;

package/lib/markets/price/signedPrices.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSignedPricesOrderType = exports.isValidSignedPricesChain = exports.validateSignedPricesPairs = exports.fetchSignedLookbackPricesWithRetry = exports.fetchSignedPricesWithRetry = exports.fetchSignedLookbackPrices = exports.fetchSignedPrices = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const types_1 = require("../../contracts/types");
+const trade_1 = require("../../trade");
+const fetchSignedPrices = async (input) => {
+    const { minAnswers, timeoutMs, oracles, chain } = {
+        minAnswers: input.chain === types_1.ChainId.ARBITRUM_SEPOLIA ? 2 : 3,
+        timeoutMs: 1000,
+        ...input,
+    };
+    if (!(0, exports.isValidSignedPricesChain)(chain))
+        throw new Error(`Invalid chain ${chain}`);
+    const { valid, pairs } = (0, exports.validateSignedPricesPairs)(input.pairs);
+    if (!valid)
+        throw new Error(`Invalid pairs array`);
+    return await initiateSignedPricesRequest(oracles, "signPrices", JSON.stringify({ pairs, chain }), minAnswers, timeoutMs);
+};
+exports.fetchSignedPrices = fetchSignedPrices;
+const fetchSignedLookbackPrices = async (input) => {
+    const { minAnswers, timeoutMs, oracles, trader, tradeIndex, pair, orderType, currentBlock, fromBlock, chain, } = {
+        minAnswers: input.chain === types_1.ChainId.ARBITRUM_SEPOLIA ? 2 : 3,
+        timeoutMs: 6000,
+        ...input,
+    };
+    if (!(0, exports.isValidSignedPricesChain)(chain))
+        throw new Error(`Invalid chain ${chain}`);
+    if (!(0, exports.isValidSignedPricesOrderType)(orderType))
+        throw new Error(`Invalid orderType ${orderType}`);
+    if (isNaN(pair))
+        throw new Error(`Invalid pair ${pair}`);
+    if (isNaN(tradeIndex) || tradeIndex < 0)
+        throw new Error(`Invalid tradeIndex ${tradeIndex}`);
+    if (!currentBlock || !fromBlock)
+        throw new Error(`Invalid block numbers`);
+    return await initiateSignedPricesRequest(oracles, "signLookbackPrices", JSON.stringify({
+        trader,
+        tradeIndex,
+        pair,
+        orderType,
+        currentBlock,
+        fromBlock,
+        chain,
+    }), minAnswers, timeoutMs);
+};
+exports.fetchSignedLookbackPrices = fetchSignedLookbackPrices;
+// Helper to determine if an error is likely transient
+const isTransientError = (error) => {
+    const message = (error instanceof Error ? error.message : String(error))?.toLowerCase() ||
+        "";
+    return (message.includes("timeout") ||
+        message.includes("aborted") ||
+        message.includes("not enough valid signed prices") ||
+        message.includes("network") ||
+        message.includes("fetch failed"));
+};
+// Fetch signed prices with retry logic for transient failures
+const fetchSignedPricesWithRetry = async (input, retryOptions) => {
+    const { maxRetries = 2, retryDelayMs = 500, backoffMultiplier = 1.5, } = retryOptions || {};
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await (0, exports.fetchSignedPrices)(input);
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry non-transient errors or if we're out of retries
+            if (attempt === maxRetries || !isTransientError(error)) {
+                throw error;
+            }
+            // Wait with exponential backoff before retry
+            const delay = Math.floor(retryDelayMs * Math.pow(backoffMultiplier, attempt));
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+};
+exports.fetchSignedPricesWithRetry = fetchSignedPricesWithRetry;
+// Fetch lookback prices with retry logic
+const fetchSignedLookbackPricesWithRetry = async (input, retryOptions) => {
+    const { maxRetries = 2, retryDelayMs = 1000, backoffMultiplier = 2, } = retryOptions || {};
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await (0, exports.fetchSignedLookbackPrices)(input);
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry non-transient errors or if we're out of retries
+            if (attempt === maxRetries || !isTransientError(error)) {
+                throw error;
+            }
+            // Wait with exponential backoff before retry
+            const delay = Math.floor(retryDelayMs * Math.pow(backoffMultiplier, attempt));
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+};
+exports.fetchSignedLookbackPricesWithRetry = fetchSignedLookbackPricesWithRetry;
+// @todo optional filtering to minAnswers best responses
+const initiateSignedPricesRequest = async (oracles, request, requestBody, minAnswers, timeoutMs) => {
+    try {
+        // Fetch signed prices from all oracles in parallel
+        const signedPrices = await Promise.allSettled(oracles.map(oracle => _getSignedPricesFromSigner(`${oracle.url}/${request}`, requestBody, oracle?.key, timeoutMs)));
+        // Filter out failed requests and null responses, then sort by signerId
+        const successfulResponses = signedPrices.filter(res => res.status === "fulfilled" && res.value !== null // Filter out failed or null responses
+        )
+            // Extract `value`
+            .map((res) => res.value)
+            // Sort by signerId, contracts expect signerId ascending
+            .sort((a, b) => a.signedData.signerId - b.signedData.signerId);
+        // Ensure we have at least `minAnswers` valid responses
+        if (successfulResponses.length < minAnswers) {
+            throw new Error(`Not enough valid signed prices. Wanted ${minAnswers} but got ${successfulResponses.length}`);
+        }
+        return successfulResponses;
+    }
+    catch (e) {
+        console.error("Error processing signed prices", e);
+        throw e;
+    }
+};
+const _getSignedPricesFromSigner = async (url, requestBody, authKey, timeoutMs) => {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, timeoutMs || 2000);
+        const response = await fetch(`${url}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": authKey || "",
+            },
+            body: requestBody,
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch signed prices from ${url}: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        console.error(`Error fetching signed prices from ${url}:`, {
+            error: error?.message,
+        });
+        return null;
+    }
+};
+const validateSignedPricesPairs = (pairs) => {
+    if (!Array.isArray(pairs) || pairs?.length === 0 || pairs.some(p => isNaN(p)))
+        return { valid: false, pairs: [] };
+    // Pairs must always be in ascending order
+    return { valid: true, pairs: [...new Set(pairs)].sort((a, b) => a - b) };
+};
+exports.validateSignedPricesPairs = validateSignedPricesPairs;
+const isValidSignedPricesChain = (chainId) => {
+    return (!isNaN(chainId) &&
+        [
+            types_1.ChainId.POLYGON,
+            types_1.ChainId.BASE,
+            types_1.ChainId.ARBITRUM,
+            types_1.ChainId.ARBITRUM_SEPOLIA,
+            types_1.ChainId.APECHAIN,
+        ].includes(chainId));
+};
+exports.isValidSignedPricesChain = isValidSignedPricesChain;
+const isValidSignedPricesOrderType = (orderType) => {
+    return (!isNaN(orderType) &&
+        [
+            trade_1.PendingOrderType.LIMIT_OPEN,
+            trade_1.PendingOrderType.STOP_OPEN,
+            trade_1.PendingOrderType.TP_CLOSE,
+            trade_1.PendingOrderType.SL_CLOSE,
+            trade_1.PendingOrderType.LIQ_CLOSE,
+        ].includes(orderType));
+};
+exports.isValidSignedPricesOrderType = isValidSignedPricesOrderType;

package/lib/markets/price/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @dev Market price types for calculating price with skew impact
+ */
+export type MarketPriceInput = {
+    collateralIndex: number;
+    pairIndex: number;
+    oraclePrice: number;
+    long: boolean;
+    open: boolean;
+    positionSizeCollateral: number;
+};
+export type MarketPriceResult = {
+    marketPrice: number;
+    skewImpactP: number;
+    oraclePrice: number;
+};
+export type MarketPriceContext = {
+    skewDepth: number;
+    pairOiToken: {
+        oiLongToken: number;
+        oiShortToken: number;
+    };
+};
+/**
+ * @dev Types for signed prices data structure
+ */
+export type SignedPricesResponse = {
+    signedData: SignedPrices;
+    missingPrices: number[];
+};
+export type SignedPrices = {
+    signerId: number;
+    expiryTs: number;
+    fromBlock: number;
+    isLookback: boolean;
+    pairIndices: number[];
+    prices: Price[];
+    signature: string;
+};
+export type Price = {
+    open: string;
+    high: string;
+    low: string;
+    current: string;
+    ts: number;
+};
+export type Oracle = {
+    url: string;
+    key?: string;
+};

package/lib/markets/price/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Market price types for calculating price with skew impact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });