@gainsnetwork/sdk 1.4.4 → 1.5.0-rc1

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

@@ -1,6 +1,7 @@
 import { TradeContainer, TradeContainerRaw } from "../../trade/types";
 import { Contracts, BlockTag } from "../../contracts/types";
 export type FetchOpenPairTradesOverrides = {
+    traders?: string[];
     batchSize?: number;
     useMulticall?: boolean;
     includeLimits?: boolean;

package/lib/contracts/utils/openTrades.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
 const ethcall_1 = require("ethcall");
+const ethers_1 = require("ethers");
 const trade_1 = require("../../trade");
 const fetchOpenPairTrades = async (contracts, overrides = {}) => {
     const rawTrades = await (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
@@ -15,12 +16,11 @@ const fetchOpenPairTrades = async (contracts, overrides = {}) => {
     return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, rawTrade.tradeFeesData, rawTrade.uiRealizedPnlData, collateralConfigs[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
 };
 exports.fetchOpenPairTrades = fetchOpenPairTrades;
-// @todo rename
 const fetchOpenPairTradesRaw = async (contracts, overrides = {}) => {
     if (!contracts) {
         return [];
     }
-    const { batchSize = 50, includeLimits = true, useMulticall = false, includeUIRealizedPnlData = true, } = overrides;
+    const { batchSize = 50, includeLimits = true, useMulticall = false, includeUIRealizedPnlData = true, traders = [], } = overrides;
     const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
     try {
         const multicallCtx = {
@@ -29,6 +29,8 @@ const fetchOpenPairTradesRaw = async (contracts, overrides = {}) => {
                 ...multiCollatDiamondContract.interface.fragments,
             ]),
         };
+        const validatedAddresses = _validateAddresses(traders || []);
+        const forTraders = validatedAddresses.length > 0;
         if (useMulticall) {
             await multicallCtx.provider.init(multiCollatDiamondContract.provider);
         }
@@ -36,11 +38,17 @@ const fetchOpenPairTradesRaw = async (contracts, overrides = {}) => {
         let running = true;
         let offset = 0;
         while (running) {
-            const [trades, tradeInfos, tradeLiquidationParams] = await Promise.all([
-                multiCollatDiamondContract.getAllTrades(offset, offset + batchSize),
-                multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize),
-                multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize),
-            ]);
+            const [trades, tradeInfos, tradeLiquidationParams] = await Promise.all(forTraders
+                ? [
+                    multiCollatDiamondContract.getAllTradesForTraders(validatedAddresses, offset, offset + batchSize),
+                    multiCollatDiamondContract.getAllTradeInfosForTraders(validatedAddresses, offset, offset + batchSize),
+                    multiCollatDiamondContract.getAllTradesLiquidationParamsForTraders(validatedAddresses, offset, offset + batchSize),
+                ]
+                : [
+                    multiCollatDiamondContract.getAllTrades(offset, offset + batchSize),
+                    multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize),
+                    multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize),
+                ]);
             const fundingFeesCallParams = [
                 [],
                 [], // indices
@@ -153,3 +161,12 @@ const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeI
             : undefined,
     };
 };
+/**
+ * Filters out duplicate addresses. Throws error if an invalid address is provided.
+ * @param addresses
+ */
+const _validateAddresses = (addresses) => {
+    return [
+        ...new Set(addresses.map(address => ethers_1.ethers.utils.getAddress(address))),
+    ];
+};

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

@@ -1,6 +1,6 @@
 "use strict";
 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 */
@@ -31,26 +31,85 @@ const fetchPairs = async (contracts, pairIxs) => {
     }
 };
 exports.fetchPairs = fetchPairs;
-const fetchPairDepths = async (contracts, pairIxs) => {
+const fetchPairDepthBands = async (contracts, pairIxs) => {
+    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 = await multiCollatContract["getPairDepthBands(uint256[])"](pairIxs);
+        return depthBands;
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pair depth bands!`);
+        throw error;
+    }
+};
+exports.fetchPairDepthBands = fetchPairDepthBands;
+const fetchPairDepthBandsDecoded = async (contracts, pairIxs) => {
+    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] = await 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 = async (contracts) => {
+    if (!contracts) {
+        return { slot1: "0", slot2: "0" };
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns two uint256 slots
+        const [slot1, slot2] = await 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 = async (contracts) => {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const pairParams = await 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 = await 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 = async (contracts, feeIxs) => {
     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/markets/oi/fetcher.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @dev Fetchers for retrieving OI data from contracts
+ * @dev Consolidates the three OI storage systems into unified format
+ */
+import { ethers } from "ethers";
+import { ChainId } from "../../contracts/types";
+import { UnifiedPairOi } from "./types";
+/**
+ * @dev Fetches all OI data for a single pair
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns Unified PairOi structure with all OI data
+ */
+export declare function fetchPairOi(chainId: ChainId, collateralIndex: number, pairIndex: number, signer: ethers.Signer): Promise<UnifiedPairOi>;
+/**
+ * @dev Fetches OI data for multiple pairs efficiently
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndices Array of trading pairs
+ * @param signer Ethers signer
+ * @returns Array of unified PairOi structures
+ */
+export declare function fetchMultiplePairOi(chainId: ChainId, collateralIndex: number, pairIndices: number[], signer: ethers.Signer): Promise<UnifiedPairOi[]>;
+/**
+ * @dev Creates OI context for fee calculations
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns OI data formatted for SDK calculations
+ */
+export declare function createOiContext(chainId: ChainId, collateralIndex: number, pairIndex: number, signer: ethers.Signer): Promise<{
+    pairOi: UnifiedPairOi;
+    currentPrice: number;
+    computed: {
+        totalDynamicOi: {
+            long: number;
+            short: number;
+        };
+        totalStaticOi: {
+            long: number;
+            short: number;
+        };
+        skew: number;
+    };
+}>;
+/**
+ * @dev Fetches only the OI data needed for specific use cases
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param useCase Which OI systems to fetch
+ * @param signer Ethers signer
+ * @returns Partial OI data based on use case
+ */
+export declare function fetchOiForUseCase(chainId: ChainId, collateralIndex: number, pairIndex: number, useCase: "skew" | "funding" | "borrowingV1" | "limits", signer: ethers.Signer): Promise<Partial<UnifiedPairOi>>;

package/lib/markets/oi/fetcher.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * @dev Fetchers for retrieving OI data from contracts
+ * @dev Consolidates the three OI storage systems into unified format
+ */
+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.fetchOiForUseCase = exports.createOiContext = exports.fetchMultiplePairOi = exports.fetchPairOi = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../contracts");
+const generated_1 = require("../../contracts/types/generated");
+const converter_1 = require("./converter");
+/**
+ * @dev Fetches all OI data for a single pair
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns Unified PairOi structure with all OI data
+ */
+function fetchPairOi(chainId, collateralIndex, pairIndex, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addresses = (0, contracts_1.getContractAddressesForChain)(chainId);
+        const diamond = generated_1.GNSMultiCollatDiamond__factory.connect(addresses.gnsMultiCollatDiamond, signer);
+        // Fetch all three OI types in parallel
+        const [beforeV10Raw, afterV10Collateral, afterV10Token, maxOi, collateral] = yield Promise.all([
+            diamond.getPairOisBeforeV10Collateral(collateralIndex, pairIndex),
+            diamond.getPairOiAfterV10Collateral(collateralIndex, pairIndex),
+            diamond.getPairOiAfterV10Token(collateralIndex, pairIndex),
+            diamond.getPairMaxOi(collateralIndex, pairIndex),
+            diamond.getCollateral(collateralIndex),
+        ]);
+        // Convert the beforeV10 format to match expected structure
+        const beforeV10 = {
+            long: beforeV10Raw.longOi,
+            short: beforeV10Raw.shortOi,
+            max: maxOi,
+            __placeholder: ethers_1.ethers.BigNumber.from(0),
+        };
+        return (0, converter_1.convertPairOi)(beforeV10, afterV10Collateral, afterV10Token, Number(collateral.precision));
+    });
+}
+exports.fetchPairOi = fetchPairOi;
+/**
+ * @dev Fetches OI data for multiple pairs efficiently
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndices Array of trading pairs
+ * @param signer Ethers signer
+ * @returns Array of unified PairOi structures
+ */
+function fetchMultiplePairOi(chainId, collateralIndex, pairIndices, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addresses = (0, contracts_1.getContractAddressesForChain)(chainId);
+        const diamond = generated_1.GNSMultiCollatDiamond__factory.connect(addresses.gnsMultiCollatDiamond, signer);
+        // Get collateral precision once
+        const collateral = yield diamond.getCollateral(collateralIndex);
+        const precision = Number(collateral.precision);
+        // Batch fetch all OI data
+        const promises = pairIndices.map((pairIndex) => __awaiter(this, void 0, void 0, function* () {
+            const [beforeV10Raw, afterV10Collateral, afterV10Token, maxOi] = yield Promise.all([
+                diamond.getPairOisBeforeV10Collateral(collateralIndex, pairIndex),
+                diamond.getPairOiAfterV10Collateral(collateralIndex, pairIndex),
+                diamond.getPairOiAfterV10Token(collateralIndex, pairIndex),
+                diamond.getPairMaxOi(collateralIndex, pairIndex),
+            ]);
+            // Convert the beforeV10 format to match expected structure
+            const beforeV10 = {
+                long: beforeV10Raw.longOi,
+                short: beforeV10Raw.shortOi,
+                max: maxOi,
+                __placeholder: ethers_1.ethers.BigNumber.from(0),
+            };
+            return {
+                beforeV10: beforeV10,
+                collateral: afterV10Collateral,
+                token: afterV10Token,
+            };
+        }));
+        const results = yield Promise.all(promises);
+        return (0, converter_1.convertPairOiArray)(results, precision);
+    });
+}
+exports.fetchMultiplePairOi = fetchMultiplePairOi;
+/**
+ * @dev Creates OI context for fee calculations
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns OI data formatted for SDK calculations
+ */
+function createOiContext(chainId, collateralIndex, pairIndex, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Fetch OI data
+        const pairOi = yield fetchPairOi(chainId, collateralIndex, pairIndex, signer);
+        // For now, use a placeholder price - in real usage, this would come from price feeds
+        // The actual price should be fetched from the price aggregator or oracle
+        const currentPrice = 1; // Placeholder - replace with actual price fetching
+        // Compute derived values
+        const totalDynamicOi = {
+            long: pairOi.beforeV10Collateral.long + pairOi.token.long * currentPrice,
+            short: pairOi.beforeV10Collateral.short + pairOi.token.short * currentPrice,
+        };
+        const totalStaticOi = {
+            long: pairOi.beforeV10Collateral.long + pairOi.collateral.long,
+            short: pairOi.beforeV10Collateral.short + pairOi.collateral.short,
+        };
+        const skew = pairOi.token.long - pairOi.token.short;
+        return {
+            pairOi,
+            currentPrice,
+            computed: {
+                totalDynamicOi,
+                totalStaticOi,
+                skew,
+            },
+        };
+    });
+}
+exports.createOiContext = createOiContext;
+/**
+ * @dev Fetches only the OI data needed for specific use cases
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param useCase Which OI systems to fetch
+ * @param signer Ethers signer
+ * @returns Partial OI data based on use case
+ */
+function fetchOiForUseCase(chainId, collateralIndex, pairIndex, useCase, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addresses = (0, contracts_1.getContractAddressesForChain)(chainId);
+        const diamond = generated_1.GNSMultiCollatDiamond__factory.connect(addresses.gnsMultiCollatDiamond, signer);
+        switch (useCase) {
+            case "skew":
+            case "funding": {
+                // Only need token OI
+                const tokenOi = yield diamond.getPairOiAfterV10Token(collateralIndex, pairIndex);
+                return {
+                    token: (0, converter_1.convertTokenOi)(tokenOi),
+                };
+            }
+            case "borrowingV1": {
+                // Need beforeV10 and token (for dynamic calculation)
+                const [beforeV10Raw, tokenOi, collateral, maxOi] = yield Promise.all([
+                    diamond.getPairOisBeforeV10Collateral(collateralIndex, pairIndex),
+                    diamond.getPairOiAfterV10Token(collateralIndex, pairIndex),
+                    diamond.getCollateral(collateralIndex),
+                    diamond.getPairMaxOi(collateralIndex, pairIndex),
+                ]);
+                // Convert the beforeV10 format to match expected structure
+                const beforeV10 = {
+                    long: beforeV10Raw.longOi,
+                    short: beforeV10Raw.shortOi,
+                    max: maxOi,
+                    __placeholder: ethers_1.ethers.BigNumber.from(0),
+                };
+                return {
+                    beforeV10Collateral: (0, converter_1.convertBeforeV10Collateral)(beforeV10, Number(collateral.precision)),
+                    token: (0, converter_1.convertTokenOi)(tokenOi),
+                };
+            }
+            case "limits": {
+                // Need all OI for limit checks
+                return fetchPairOi(chainId, collateralIndex, pairIndex, signer);
+            }
+            default:
+                throw new Error(`Unknown use case: ${String(useCase)}`);
+        }
+    });
+}
+exports.fetchOiForUseCase = fetchOiForUseCase;

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

@@ -0,0 +1,80 @@
+/**
+ * @dev OI Validation module
+ * @dev Provides validation functions for Open Interest limits
+ */
+import { UnifiedPairOi } from "./types";
+import * as BorrowingFee from "../../trade/fees/borrowing/types";
+import { PairIndex } from "../../trade/types";
+/**
+ * @dev Check if a position would exceed per-pair OI limits
+ * @param pairOi Current OI data for the pair
+ * @param long Whether the position is long
+ * @param positionSizeCollateral Position size in collateral
+ * @param currentPrice Current collateral price in USD (required for dynamic OI)
+ * @returns true if within limits, false if would exceed
+ */
+export declare const withinMaxPairOi: (pairOi: UnifiedPairOi, long: boolean, positionSizeCollateral: number, currentPrice: number) => boolean;
+/**
+ * @dev Calculate dynamic OI for a specific side
+ * @param pairOi OI data for the pair
+ * @param currentPrice Current collateral price in USD
+ * @param long Whether to calculate for long side
+ * @returns Dynamic OI in collateral value
+ */
+export declare const calculateDynamicOi: (pairOi: UnifiedPairOi, currentPrice: number, long: boolean) => number;
+/**
+ * @dev Calculate remaining OI capacity for a side
+ * @param pairOi OI data for the pair
+ * @param currentPrice Current collateral price in USD
+ * @param long Whether to calculate for long side
+ * @returns Remaining capacity in collateral (0 if unlimited)
+ */
+export declare const getRemainingOiCapacity: (pairOi: UnifiedPairOi, currentPrice: number, long: boolean) => number;
+/**
+ * @dev Updated group OI validation using dynamic OI
+ * @param pairIndex Index of the trading pair
+ * @param long Whether the position is long
+ * @param positionSizeCollateral Position size in collateral
+ * @param currentPrice Current collateral price in USD
+ * @param context Context with groups, pairs, and OI data
+ * @returns true if within group limits, false if would exceed
+ */
+export declare const withinMaxGroupOiDynamic: (pairIndex: PairIndex, long: boolean, positionSizeCollateral: number, currentPrice: number, context: {
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+    pairOis: UnifiedPairOi[];
+}) => boolean;
+/**
+ * @dev Calculate total dynamic OI for a group
+ * @param groupIndex Index of the group
+ * @param currentPrice Current collateral price in USD
+ * @param context Context with pairs and OI data
+ * @returns Total dynamic OI for the group
+ */
+export declare const getGroupDynamicOi: (groupIndex: number, currentPrice: number, context: {
+    pairs: BorrowingFee.Pair[];
+    pairOis: UnifiedPairOi[];
+}) => {
+    long: number;
+    short: number;
+    total: number;
+};
+/**
+ * @dev Check both pair and group OI limits
+ * @param pairIndex Index of the trading pair
+ * @param long Whether the position is long
+ * @param positionSizeCollateral Position size in collateral
+ * @param currentPrice Current collateral price in USD
+ * @param context Full context with all required data
+ * @returns Object with validation results
+ */
+export declare const validateOiLimits: (pairIndex: PairIndex, long: boolean, positionSizeCollateral: number, currentPrice: number, context: {
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+    pairOis: UnifiedPairOi[];
+}) => {
+    withinPairLimit: boolean;
+    withinGroupLimit: boolean;
+    pairRemainingCapacity: number;
+    groupRemainingCapacity: number;
+};