@gainsnetwork/sdk 0.2.67-rc6 → 0.2.67-rc8

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/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @dev Main export file for OI module
+ * @dev Provides unified Open Interest management functionality
+ */
+export { UnifiedPairOi, GroupOi, OiUsageMetadata, ComputedOi } from "./types";
+export { convertBeforeV10Collateral, convertCollateralOi, convertTokenOi, convertPairOi, convertPairOiArray, computeOiValues, } from "./converter";
+export { fetchPairOi, fetchMultiplePairOi, createOiContext, fetchOiForUseCase, } from "./fetcher";
+export { withinMaxPairOi, calculateDynamicOi, getRemainingOiCapacity, withinMaxGroupOiDynamic, getGroupDynamicOi, validateOiLimits, } from "./validation";
+import { OiUsageMetadata } from "./types";
+export declare const OI_USAGE: OiUsageMetadata;

package/lib/markets/oi/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * @dev Main export file for OI module
+ * @dev Provides unified Open Interest management functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OI_USAGE = exports.validateOiLimits = exports.getGroupDynamicOi = exports.withinMaxGroupOiDynamic = exports.getRemainingOiCapacity = exports.calculateDynamicOi = exports.withinMaxPairOi = exports.fetchOiForUseCase = exports.createOiContext = exports.fetchMultiplePairOi = exports.fetchPairOi = exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = void 0;
+// 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; } });
+// Fetchers
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "fetchPairOi", { enumerable: true, get: function () { return fetcher_1.fetchPairOi; } });
+Object.defineProperty(exports, "fetchMultiplePairOi", { enumerable: true, get: function () { return fetcher_1.fetchMultiplePairOi; } });
+Object.defineProperty(exports, "createOiContext", { enumerable: true, get: function () { return fetcher_1.createOiContext; } });
+Object.defineProperty(exports, "fetchOiForUseCase", { enumerable: true, get: function () { return fetcher_1.fetchOiForUseCase; } });
+// Validation
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "withinMaxPairOi", { enumerable: true, get: function () { return validation_1.withinMaxPairOi; } });
+Object.defineProperty(exports, "calculateDynamicOi", { enumerable: true, get: function () { return validation_1.calculateDynamicOi; } });
+Object.defineProperty(exports, "getRemainingOiCapacity", { enumerable: true, get: function () { return validation_1.getRemainingOiCapacity; } });
+Object.defineProperty(exports, "withinMaxGroupOiDynamic", { enumerable: true, get: function () { return validation_1.withinMaxGroupOiDynamic; } });
+Object.defineProperty(exports, "getGroupDynamicOi", { enumerable: true, get: function () { return validation_1.getGroupDynamicOi; } });
+Object.defineProperty(exports, "validateOiLimits", { enumerable: true, get: function () { return validation_1.validateOiLimits; } });
+exports.OI_USAGE = {
+    borrowingV1: ["beforeV10Collateral", "token"],
+    fundingFees: ["token"],
+    skewImpact: ["token"],
+    maxPairOi: ["beforeV10Collateral", "token"],
+    maxGroupOi: ["beforeV10Collateral", "token"],
+    maxSkew: ["token"], // V10+ only: uses token OI
+};

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

@@ -0,0 +1,82 @@
+/**
+ * @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;
+    };
+}
+/**
+ * @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 Metadata describing which OI systems are used by different features
+ * @dev Helps consumers understand OI usage patterns
+ */
+export interface OiUsageMetadata {
+    borrowingV1: Array<"beforeV10Collateral" | "token">;
+    fundingFees: Array<"token">;
+    skewImpact: Array<"token">;
+    maxPairOi: Array<"beforeV10Collateral" | "token">;
+    maxGroupOi: Array<"beforeV10Collateral" | "token">;
+    maxSkew: Array<"token">;
+}
+/**
+ * @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 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/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;
+};

package/lib/markets/oi/validation.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * @dev OI Validation module
+ * @dev Provides validation functions for Open Interest limits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOiLimits = exports.getGroupDynamicOi = exports.withinMaxGroupOiDynamic = exports.getRemainingOiCapacity = exports.calculateDynamicOi = exports.withinMaxPairOi = void 0;
+const converter_1 = require("./converter");
+/**
+ * @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
+ */
+const withinMaxPairOi = (pairOi, long, positionSizeCollateral, currentPrice) => {
+    // If maxCollateral is 0, unlimited OI allowed
+    if (pairOi.maxCollateral === 0) {
+        return true;
+    }
+    // Calculate current dynamic OI
+    const computed = (0, converter_1.computeOiValues)(pairOi, currentPrice);
+    const currentOi = long
+        ? computed.totalDynamicCollateral.long
+        : computed.totalDynamicCollateral.short;
+    // Check if adding position would exceed max
+    const newOi = currentOi + positionSizeCollateral;
+    return newOi <= pairOi.maxCollateral;
+};
+exports.withinMaxPairOi = withinMaxPairOi;
+/**
+ * @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
+ */
+const calculateDynamicOi = (pairOi, currentPrice, long) => {
+    const computed = (0, converter_1.computeOiValues)(pairOi, currentPrice);
+    return long
+        ? computed.totalDynamicCollateral.long
+        : computed.totalDynamicCollateral.short;
+};
+exports.calculateDynamicOi = calculateDynamicOi;
+/**
+ * @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)
+ */
+const getRemainingOiCapacity = (pairOi, currentPrice, long) => {
+    // If maxCollateral is 0, unlimited capacity
+    if (pairOi.maxCollateral === 0) {
+        return 0; // Indicates unlimited
+    }
+    const dynamicOi = (0, exports.calculateDynamicOi)(pairOi, currentPrice, long);
+    const remaining = pairOi.maxCollateral - dynamicOi;
+    // Return 0 if already at or over capacity
+    return Math.max(0, remaining);
+};
+exports.getRemainingOiCapacity = getRemainingOiCapacity;
+/**
+ * @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
+ */
+const withinMaxGroupOiDynamic = (pairIndex, long, positionSizeCollateral, currentPrice, context) => {
+    const pair = context.pairs[pairIndex];
+    if (!pair)
+        return false;
+    // Get group index from first group in pair's groups array
+    const groupIndex = pair.groups.length > 0 ? pair.groups[0].groupIndex : 0;
+    const group = context.groups[groupIndex];
+    if (!group)
+        return false;
+    // If maxOi is 0, unlimited OI allowed
+    if (group.oi.max === 0) {
+        return true;
+    }
+    // Calculate total dynamic OI for all pairs in group
+    let totalGroupOi = 0;
+    context.pairs.forEach((p, idx) => {
+        const pGroupIndex = p.groups.length > 0 ? p.groups[0].groupIndex : 0;
+        if (pGroupIndex === groupIndex && context.pairOis[idx]) {
+            const pairOi = context.pairOis[idx];
+            const computed = (0, converter_1.computeOiValues)(pairOi, currentPrice);
+            // Add both long and short OI for the pair
+            totalGroupOi +=
+                computed.totalDynamicCollateral.long +
+                    computed.totalDynamicCollateral.short;
+        }
+    });
+    // Check if adding position would exceed group max
+    const newTotalOi = totalGroupOi + positionSizeCollateral;
+    return newTotalOi <= group.oi.max;
+};
+exports.withinMaxGroupOiDynamic = withinMaxGroupOiDynamic;
+/**
+ * @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
+ */
+const getGroupDynamicOi = (groupIndex, currentPrice, context) => {
+    let longOi = 0;
+    let shortOi = 0;
+    context.pairs.forEach((p, idx) => {
+        const pGroupIndex = p.groups.length > 0 ? p.groups[0].groupIndex : 0;
+        if (pGroupIndex === groupIndex && context.pairOis[idx]) {
+            const pairOi = context.pairOis[idx];
+            const computed = (0, converter_1.computeOiValues)(pairOi, currentPrice);
+            longOi += computed.totalDynamicCollateral.long;
+            shortOi += computed.totalDynamicCollateral.short;
+        }
+    });
+    return {
+        long: longOi,
+        short: shortOi,
+        total: longOi + shortOi,
+    };
+};
+exports.getGroupDynamicOi = getGroupDynamicOi;
+/**
+ * @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
+ */
+const validateOiLimits = (pairIndex, long, positionSizeCollateral, currentPrice, context) => {
+    const pairOi = context.pairOis[pairIndex];
+    if (!pairOi) {
+        return {
+            withinPairLimit: false,
+            withinGroupLimit: false,
+            pairRemainingCapacity: 0,
+            groupRemainingCapacity: 0,
+        };
+    }
+    // Check pair limits
+    const withinPairLimit = (0, exports.withinMaxPairOi)(pairOi, long, positionSizeCollateral, currentPrice);
+    const pairRemainingCapacity = (0, exports.getRemainingOiCapacity)(pairOi, currentPrice, long);
+    // Check group limits
+    const withinGroupLimit = (0, exports.withinMaxGroupOiDynamic)(pairIndex, long, positionSizeCollateral, currentPrice, context);
+    // Calculate group remaining capacity
+    const pair = context.pairs[pairIndex];
+    let groupRemainingCapacity = 0;
+    if (pair) {
+        const groupIndex = pair.groups.length > 0 ? pair.groups[0].groupIndex : 0;
+        const group = context.groups[groupIndex];
+        if (group && group.oi.max > 0) {
+            const groupOi = (0, exports.getGroupDynamicOi)(groupIndex, currentPrice, context);
+            groupRemainingCapacity = Math.max(0, group.oi.max - groupOi.total);
+        }
+    }
+    return {
+        withinPairLimit,
+        withinGroupLimit,
+        pairRemainingCapacity,
+        groupRemainingCapacity,
+    };
+};
+exports.validateOiLimits = validateOiLimits;

package/lib/trade/fees/borrowing/builder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @dev Context builder for borrowing v1 fees
+ */
+import { GlobalTradingVariablesType } from "../../../backend/tradingVariables/types";
+import { GetBorrowingFeeContext } from "./index";
+/**
+ * @dev Builds borrowing v1 context from global trading variables
+ * @dev Returns full array-based context required for v1 borrowing fee calculations
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex Collateral index (1-based)
+ * @param currentBlock Current block number
+ * @returns Full borrowing context with all pairs and groups or undefined if data not available
+ */
+export declare const buildBorrowingV1Context: (globalTradingVariables: GlobalTradingVariablesType, collateralIndex: number, currentBlock: number) => GetBorrowingFeeContext | undefined;

package/lib/trade/fees/borrowing/builder.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @dev Context builder for borrowing v1 fees
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBorrowingV1Context = void 0;
+/**
+ * @dev Builds borrowing v1 context from global trading variables
+ * @dev Returns full array-based context required for v1 borrowing fee calculations
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex Collateral index (1-based)
+ * @param currentBlock Current block number
+ * @returns Full borrowing context with all pairs and groups or undefined if data not available
+ */
+const buildBorrowingV1Context = (globalTradingVariables, collateralIndex, currentBlock) => {
+    var _a;
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!(collateral === null || collateral === void 0 ? void 0 : collateral.pairBorrowingFees) || !(collateral === null || collateral === void 0 ? void 0 : collateral.groupBorrowingFees)) {
+        return undefined;
+    }
+    const pairs = collateral.pairBorrowingFees;
+    const groups = collateral.groupBorrowingFees;
+    if (pairs.length === 0 || groups.length === 0) {
+        return undefined;
+    }
+    return {
+        currentBlock,
+        pairs,
+        groups,
+        collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+    };
+};
+exports.buildBorrowingV1Context = buildBorrowingV1Context;

package/lib/trade/fees/borrowingV2/builder.d.ts

@@ -0,0 +1,6 @@
+import { GlobalTradingVariablesType } from "../../../backend/tradingVariables/types";
+import { GetPairBorrowingFeeV2Context } from "./types";
+/**
+ * @dev Builds borrowing v2 sub-context for a specific pair
+ */
+export declare const buildBorrowingV2Context: (globalTradingVariables: GlobalTradingVariablesType, collateralIndex: number, pairIndex: number, currentTimestamp: number) => GetPairBorrowingFeeV2Context | undefined;

package/lib/trade/fees/borrowingV2/builder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBorrowingV2Context = void 0;
+/**
+ * @dev Builds borrowing v2 sub-context for a specific pair
+ */
+const buildBorrowingV2Context = (globalTradingVariables, collateralIndex, pairIndex, currentTimestamp) => {
+    var _a, _b;
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!(collateral === null || collateral === void 0 ? void 0 : collateral.pairBorrowingFeesV2)) {
+        return undefined;
+    }
+    const params = (_a = collateral.pairBorrowingFeesV2.params) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const data = (_b = collateral.pairBorrowingFeesV2.data) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    if (!params || !data) {
+        return undefined;
+    }
+    return {
+        params,
+        data,
+        currentTimestamp,
+    };
+};
+exports.buildBorrowingV2Context = buildBorrowingV2Context;