@gainsnetwork/sdk 0.0.0-v10.rc2 → 0.0.0-v10.rc20

package/lib/markets/leverage/getMarketLeverageRestrictions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketLeverageRestrictions = void 0;
+/**
+ * Gets the leverage restrictions for a trading pair, including both regular and counter trade limits
+ * @param context Context containing group limits, pair overrides, and counter trade settings
+ * @returns Object with regular and counter trade leverage restrictions
+ */
+const getMarketLeverageRestrictions = (context) => {
+    const { groupMinLeverage, groupMaxLeverage, pairMaxLeverage, counterTradeSettings, } = context;
+    // Calculate regular trade leverage limits
+    let regularMin = groupMinLeverage;
+    let regularMax = pairMaxLeverage === undefined || pairMaxLeverage === 0
+        ? groupMaxLeverage
+        : pairMaxLeverage;
+    // If max is less than min, set both to 0 (pair is effectively disabled)
+    if (regularMax < regularMin) {
+        regularMin = 0;
+        regularMax = 0;
+    }
+    // Calculate counter trade leverage limits if settings exist
+    let counterTradeLimits = null;
+    if (counterTradeSettings) {
+        // Counter trades use the group's min leverage but have their own max leverage
+        counterTradeLimits = {
+            min: groupMinLeverage,
+            max: counterTradeSettings.maxLeverage,
+        };
+    }
+    return {
+        regular: {
+            min: regularMin,
+            max: regularMax,
+        },
+        counterTrade: counterTradeLimits,
+    };
+};
+exports.getMarketLeverageRestrictions = getMarketLeverageRestrictions;

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

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./getMarketLeverageRestrictions";
+export * from "./builder";

package/lib/markets/leverage/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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("./getMarketLeverageRestrictions"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,15 @@
+import { CounterTradeSettings } from "../../trade/types";
+export type LeverageRestrictions = {
+    min: number;
+    max: number;
+};
+export type MarketLeverageRestrictions = {
+    regular: LeverageRestrictions;
+    counterTrade: LeverageRestrictions | null;
+};
+export type GetMarketLeverageRestrictionsContext = {
+    groupMinLeverage: number;
+    groupMaxLeverage: number;
+    pairMaxLeverage?: number;
+    counterTradeSettings?: CounterTradeSettings;
+};

package/lib/markets/leverage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,62 @@
+/**
+ * @dev Converters for OI data between contract and SDK formats
+ * @dev Handles the three OI storage systems and precision conversions
+ */
+import { IBorrowingFees, IPriceImpact } from "../../contracts/types/generated/GNSMultiCollatDiamond";
+import { UnifiedPairOi, ComputedOi } from "./types";
+/**
+ * @dev Converts pre-v10 OI from contract format
+ * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
+ * @returns Normalized OI with long/short values
+ */
+export declare const convertBeforeV10Collateral: (contractOi: IBorrowingFees.OpenInterestStructOutput) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts post-v10 collateral OI from contract format
+ * @param contractOi Contract PairOiCollateral struct
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+export declare const convertCollateralOi: (contractOi: IPriceImpact.PairOiCollateralStructOutput, precision: number) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts post-v10 token OI from contract format
+ * @param contractOi Contract PairOiToken struct
+ * @returns Normalized OI with long/short values (1e18 precision)
+ */
+export declare const convertTokenOi: (contractOi: IPriceImpact.PairOiTokenStructOutput) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts all OI data for a pair into unified structure
+ * @param beforeV10 Pre-v10 OI from BorrowingFeesStorage
+ * @param afterV10Collateral Post-v10 collateral OI from PriceImpactStorage
+ * @param afterV10Token Post-v10 token OI from PriceImpactStorage
+ * @param maxOi Maximum OI allowed (from BorrowingFeesStorage)
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Unified PairOi structure
+ */
+export declare const convertPairOi: (beforeV10: IBorrowingFees.OpenInterestStructOutput, afterV10Collateral: IPriceImpact.PairOiCollateralStructOutput, afterV10Token: IPriceImpact.PairOiTokenStructOutput, collateralPrecision: number) => UnifiedPairOi;
+/**
+ * @dev Batch converter for multiple pairs
+ * @param pairs Array of OI data for multiple pairs
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Array of unified PairOi structures
+ */
+export declare const convertPairOiArray: (pairs: Array<{
+    beforeV10: IBorrowingFees.OpenInterestStructOutput;
+    collateral: IPriceImpact.PairOiCollateralStructOutput;
+    token: IPriceImpact.PairOiTokenStructOutput;
+}>, collateralPrecision: number) => UnifiedPairOi[];
+/**
+ * @dev Computes derived OI values from unified structure
+ * @param pairOi Unified pair OI data
+ * @param tokenPriceCollateral Current token price in collateral units
+ * @returns Computed values including total OI and skew
+ */
+export declare const computeOiValues: (pairOi: UnifiedPairOi, tokenPriceCollateral: number) => ComputedOi;

package/lib/markets/oi/converter.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * @dev Converters for OI data between contract and SDK formats
+ * @dev Handles the three OI storage systems and precision conversions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = void 0;
+/**
+ * @dev Converts pre-v10 OI from contract format
+ * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
+ * @returns Normalized OI with long/short values
+ */
+const convertBeforeV10Collateral = (contractOi) => {
+    return {
+        long: Number(contractOi.long) / 1e10,
+        short: Number(contractOi.short) / 1e10,
+    };
+};
+exports.convertBeforeV10Collateral = convertBeforeV10Collateral;
+/**
+ * @dev Converts post-v10 collateral OI from contract format
+ * @param contractOi Contract PairOiCollateral struct
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+const convertCollateralOi = (contractOi, precision) => {
+    return {
+        long: Number(contractOi.oiLongCollateral) / precision,
+        short: Number(contractOi.oiShortCollateral) / precision,
+    };
+};
+exports.convertCollateralOi = convertCollateralOi;
+/**
+ * @dev Converts post-v10 token OI from contract format
+ * @param contractOi Contract PairOiToken struct
+ * @returns Normalized OI with long/short values (1e18 precision)
+ */
+const convertTokenOi = (contractOi) => {
+    return {
+        long: Number(contractOi.oiLongToken) / 1e18,
+        short: Number(contractOi.oiShortToken) / 1e18,
+    };
+};
+exports.convertTokenOi = convertTokenOi;
+/**
+ * @dev Converts all OI data for a pair into unified structure
+ * @param beforeV10 Pre-v10 OI from BorrowingFeesStorage
+ * @param afterV10Collateral Post-v10 collateral OI from PriceImpactStorage
+ * @param afterV10Token Post-v10 token OI from PriceImpactStorage
+ * @param maxOi Maximum OI allowed (from BorrowingFeesStorage)
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Unified PairOi structure
+ */
+const convertPairOi = (beforeV10, afterV10Collateral, afterV10Token, collateralPrecision) => {
+    return {
+        maxCollateral: Number(beforeV10.max) / 1e10,
+        beforeV10Collateral: (0, exports.convertBeforeV10Collateral)(beforeV10),
+        collateral: (0, exports.convertCollateralOi)(afterV10Collateral, collateralPrecision),
+        token: (0, exports.convertTokenOi)(afterV10Token),
+    };
+};
+exports.convertPairOi = convertPairOi;
+/**
+ * @dev Batch converter for multiple pairs
+ * @param pairs Array of OI data for multiple pairs
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Array of unified PairOi structures
+ */
+const convertPairOiArray = (pairs, collateralPrecision) => {
+    return pairs.map(p => (0, exports.convertPairOi)(p.beforeV10, p.collateral, p.token, collateralPrecision));
+};
+exports.convertPairOiArray = convertPairOiArray;
+/**
+ * @dev Computes derived OI values from unified structure
+ * @param pairOi Unified pair OI data
+ * @param tokenPriceCollateral Current token price in collateral units
+ * @returns Computed values including total OI and skew
+ */
+const computeOiValues = (pairOi, tokenPriceCollateral) => {
+    // Static total (used for admin operations)
+    const totalStaticLong = pairOi.beforeV10Collateral.long + pairOi.collateral.long;
+    const totalStaticShort = pairOi.beforeV10Collateral.short + pairOi.collateral.short;
+    // Dynamic total (used for real-time calculations)
+    const tokenLongCollateral = pairOi.token.long * tokenPriceCollateral;
+    const tokenShortCollateral = pairOi.token.short * tokenPriceCollateral;
+    const totalDynamicLong = pairOi.beforeV10Collateral.long + tokenLongCollateral;
+    const totalDynamicShort = pairOi.beforeV10Collateral.short + tokenShortCollateral;
+    // Skew (v10+ only, in tokens)
+    const skewToken = pairOi.token.long - pairOi.token.short;
+    return {
+        totalStaticCollateral: {
+            long: totalStaticLong,
+            short: totalStaticShort,
+        },
+        totalDynamicCollateral: {
+            long: totalDynamicLong,
+            short: totalDynamicShort,
+        },
+        skewToken,
+    };
+};
+exports.computeOiValues = computeOiValues;

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/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; } });