@gainsnetwork/sdk 0.0.0-v10.rc1 → 0.0.0-v10.rc3

package/lib/contracts/types/index.d.ts

@@ -20,7 +20,8 @@ export declare enum CollateralTypes {
 }
 export declare enum ContractsVersion {
     BEFORE_V9_2 = 0,
-    V9_2 = 1
+    V9_2 = 1,
+    V10 = 2
 }
 export type ContractAddressList = Record<string, Partial<Record<CollateralTypes | "global", Partial<ContractAddresses>>>>;
 export declare enum ChainId {

package/lib/contracts/types/index.js

@@ -14,6 +14,7 @@ var ContractsVersion;
 (function (ContractsVersion) {
     ContractsVersion[ContractsVersion["BEFORE_V9_2"] = 0] = "BEFORE_V9_2";
     ContractsVersion[ContractsVersion["V9_2"] = 1] = "V9_2";
+    ContractsVersion[ContractsVersion["V10"] = 2] = "V10";
 })(ContractsVersion = exports.ContractsVersion || (exports.ContractsVersion = {}));
 var ChainId;
 (function (ChainId) {

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

@@ -5,6 +5,7 @@ export type FetchOpenPairTradesOverrides = {
     useMulticall?: boolean;
     includeLimits?: boolean;
     blockTag?: BlockTag;
+    includeUIRealizedPnlData?: boolean;
 };
 export declare const fetchOpenPairTrades: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainer[]>;
 export declare const fetchOpenPairTradesRaw: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainerRaw[]>;

package/lib/contracts/utils/openTrades.js

@@ -11,10 +11,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
 const ethcall_1 = require("ethcall");
+const trade_1 = require("../../trade");
 const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
     const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
-    const collateralPrecisions = (yield contracts.gnsMultiCollatDiamond.getCollaterals()).map(({ precision }) => precision);
-    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
+    const collaterals = yield contracts.gnsMultiCollatDiamond.getCollaterals();
+    const collateralConfigs = collaterals.map(c => ({
+        collateral: c.collateral,
+        isActive: c.isActive,
+        precision: parseFloat(c.precision.toString()),
+        precisionDelta: parseFloat(c.precisionDelta.toString()),
+    }));
+    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
@@ -22,7 +29,7 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     if (!contracts) {
         return [];
     }
-    const { batchSize = 50, includeLimits = true, useMulticall = false, } = overrides;
+    const { batchSize = 50, includeLimits = true, useMulticall = false, includeUIRealizedPnlData = true, } = overrides;
     const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
     try {
         const multicallCtx = {
@@ -38,25 +45,52 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
         let running = true;
         let offset = 0;
         while (running) {
-            const trades = yield multiCollatDiamondContract.getAllTrades(offset, offset + batchSize);
-            const tradeInfos = yield multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize);
-            const tradeLiquidationParams = yield multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize);
+            const [trades, tradeInfos, tradeLiquidationParams] = yield Promise.all([
+                multiCollatDiamondContract.getAllTrades(offset, offset + batchSize),
+                multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize),
+                multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize),
+            ]);
+            const fundingFeesCallParams = [
+                [],
+                [], // indices
+            ];
             // Array is always of length `batchSize`
             // so we need to filter out the empty trades, indexes are reliable
             const openTrades = trades
                 .filter(t => t.collateralIndex > 0 &&
                 (includeLimits || (!includeLimits && t.tradeType === 0)))
-                .map((trade, ix) => ({
-                trade,
-                tradeInfo: tradeInfos[ix],
-                liquidationParams: tradeLiquidationParams[ix],
-                initialAccFees: {
-                    accPairFee: 0,
-                    accGroupFee: 0,
-                    block: 0,
-                    __placeholder: 0,
-                },
-            }));
+                .map((trade, ix) => {
+                fundingFeesCallParams[0].push(trade.user);
+                fundingFeesCallParams[1].push(trade.index);
+                return {
+                    trade,
+                    tradeInfo: tradeInfos[ix],
+                    liquidationParams: tradeLiquidationParams[ix],
+                    initialAccFees: {
+                        accPairFee: 0,
+                        accGroupFee: 0,
+                        block: 0,
+                        __placeholder: 0,
+                    },
+                    tradeFeesData: {
+                        realizedTradingFeesCollateral: 0,
+                        realizedPnlCollateral: 0,
+                        manuallyRealizedNegativePnlCollateral: 0,
+                        alreadyTransferredNegativePnlCollateral: 0,
+                        virtualAvailableCollateralInDiamond: 0,
+                        initialAccFundingFeeP: 0,
+                        initialAccBorrowingFeeP: 0,
+                        __placeholder: 0,
+                    },
+                    uiRealizedPnlData: undefined,
+                };
+            });
+            const [tradeFeesData, uiRealizedPnlData] = yield Promise.all([
+                multiCollatDiamondContract.getTradeFeesDataArray(...fundingFeesCallParams),
+                includeUIRealizedPnlData
+                    ? multiCollatDiamondContract.getTradeUiRealizedPnlDataArray(...fundingFeesCallParams)
+                    : [],
+            ]);
             const initialAccFeesPromises = openTrades
                 .map(({ trade }) => ({
                 collateralIndex: trade.collateralIndex,
@@ -71,6 +105,8 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                 : Promise.all(initialAccFeesPromises));
             initialAccFees.forEach((accFees, ix) => {
                 openTrades[ix].initialAccFees = accFees;
+                openTrades[ix].tradeFeesData = tradeFeesData[ix];
+                openTrades[ix].uiRealizedPnlData = uiRealizedPnlData === null || uiRealizedPnlData === void 0 ? void 0 : uiRealizedPnlData[ix];
             });
             allOpenPairTrades = allOpenPairTrades.concat(openTrades);
             offset += batchSize + 1;
@@ -85,42 +121,44 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     }
 });
 exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
-const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, collateralPrecision) => ({
-    trade: {
-        user: trade.user,
-        index: parseInt(trade.index.toString()),
-        pairIndex: parseInt(trade.pairIndex.toString()),
-        leverage: parseFloat(trade.leverage.toString()) / 1e3,
-        long: trade.long.toString() === "true",
-        isOpen: trade.isOpen.toString() === "true",
-        collateralIndex: parseInt(trade.collateralIndex.toString()),
-        tradeType: trade.tradeType,
-        collateralAmount: parseFloat(trade.collateralAmount.toString()) /
-            parseFloat(collateralPrecision.toString()),
-        openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
-        tp: parseFloat(trade.tp.toString()) / 1e10,
-        sl: parseFloat(trade.sl.toString()) / 1e10,
-    },
-    tradeInfo: {
-        createdBlock: parseInt(tradeInfo.createdBlock.toString()),
-        tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
-        slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
-        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
-        lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
-        collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
-        contractsVersion: parseInt(tradeInfo.contractsVersion.toString()),
-        lastPosIncreaseBlock: parseInt(tradeInfo.lastPosIncreaseBlock.toString()),
-    },
-    liquidationParams: {
-        maxLiqSpreadP: parseFloat(tradeLiquidationParams.maxLiqSpreadP.toString()) / 1e12,
-        startLiqThresholdP: parseFloat(tradeLiquidationParams.startLiqThresholdP.toString()) / 1e12,
-        endLiqThresholdP: parseFloat(tradeLiquidationParams.endLiqThresholdP.toString()) / 1e12,
-        startLeverage: parseFloat(tradeLiquidationParams.startLeverage.toString()) / 1e3,
-        endLeverage: parseFloat(tradeLiquidationParams.endLeverage.toString()) / 1e3,
-    },
-    initialAccFees: {
-        accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
-        accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
-        block: parseFloat(tradeInitialAccFees.block.toString()),
-    },
-});
+const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, tradeFeesData, uiRealizedPnlData, collateralConfig) => {
+    const precision = collateralConfig.precision;
+    return {
+        trade: {
+            user: trade.user,
+            index: parseInt(trade.index.toString()),
+            pairIndex: parseInt(trade.pairIndex.toString()),
+            leverage: parseFloat(trade.leverage.toString()) / 1e3,
+            long: trade.long.toString() === "true",
+            isOpen: trade.isOpen.toString() === "true",
+            collateralIndex: parseInt(trade.collateralIndex.toString()),
+            tradeType: trade.tradeType,
+            collateralAmount: parseFloat(trade.collateralAmount.toString()) / precision,
+            openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
+            tp: parseFloat(trade.tp.toString()) / 1e10,
+            sl: parseFloat(trade.sl.toString()) / 1e10,
+            isCounterTrade: trade.isCounterTrade,
+            positionSizeToken: parseFloat(trade.positionSizeToken.toString()) / 1e18,
+        },
+        tradeInfo: {
+            createdBlock: parseInt(tradeInfo.createdBlock.toString()),
+            tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
+            slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
+            maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
+            lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
+            collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
+            contractsVersion: parseInt(tradeInfo.contractsVersion.toString()),
+            lastPosIncreaseBlock: parseInt(tradeInfo.lastPosIncreaseBlock.toString()),
+        },
+        liquidationParams: (0, trade_1.convertLiquidationParams)(tradeLiquidationParams),
+        initialAccFees: {
+            accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
+            accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
+            block: parseFloat(tradeInitialAccFees.block.toString()),
+        },
+        tradeFeesData: (0, trade_1.convertTradeFeesData)(tradeFeesData, collateralConfig),
+        uiRealizedPnlData: uiRealizedPnlData
+            ? (0, trade_1.convertUiRealizedPnlData)(uiRealizedPnlData, collateralConfig)
+            : undefined,
+    };
+};

package/lib/contracts/utils/pairs.js

@@ -475,4 +475,11 @@ const PAIR_INDEX_TO_DESCRIPTION = {
     [types_1.PairIndex.WCTUSD]: "WalletConnect Token to US Dollar",
     [types_1.PairIndex.BIGTIMEUSD]: "Big Time to US Dollar",
     [types_1.PairIndex.BABYUSD]: "Babylon to US Dollar",
+    [types_1.PairIndex.COOKIEUSD]: "Cookie DAO to US Dollar",
+    [types_1.PairIndex.KMNOUSD]: "Kamino to US Dollar",
+    [types_1.PairIndex.INITUSD]: "Initia to US Dollar",
+    [types_1.PairIndex.SYRUPUSD]: "Maple Finance to US Dollar",
+    [types_1.PairIndex.SIGNUSD]: "Sign to US Dollar",
+    [types_1.PairIndex.ZORAUSD]: "ZORA to US Dollar",
+    [types_1.PairIndex.COINUSD]: "Coinbase to US Dollar",
 };

package/lib/index.d.ts

@@ -4,4 +4,5 @@ export * from "./markets";
 export * from "./constants";
 export * from "./utils";
 export * from "./vault";
+export * from "./backend";
 export * from "./trade/fees/borrowing/index";

package/lib/index.js

@@ -20,5 +20,6 @@ __exportStar(require("./markets"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./vault"), exports);
+__exportStar(require("./backend"), exports);
 // Not sure why this is needed, but it is. Barrel imports are not working.
 __exportStar(require("./trade/fees/borrowing/index"), exports);

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

@@ -0,0 +1,5 @@
+import { ITradingStorage } from "src/contracts/types/generated/GNSMultiCollatDiamond";
+import { CollateralConfig } from "./types";
+export declare const convertCollateralConfig: (collateral: ITradingStorage.CollateralStructOutput & {
+    decimals: number;
+}) => CollateralConfig;

package/lib/markets/collateral/converter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCollateralConfig = void 0;
+const convertCollateralConfig = (collateral) => ({
+    collateral: collateral.collateral,
+    isActive: collateral.isActive,
+    precision: Number(collateral.precision),
+    precisionDelta: Number(collateral.precisionDelta),
+    decimals: collateral.decimals,
+});
+exports.convertCollateralConfig = convertCollateralConfig;

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

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

package/lib/markets/collateral/index.js

@@ -0,0 +1,17 @@
+"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);

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

@@ -0,0 +1,7 @@
+export type CollateralConfig = {
+    collateral: string;
+    isActive: boolean;
+    precision: number;
+    precisionDelta: number;
+    decimals?: number;
+};

package/lib/markets/collateral/types.js

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

package/lib/markets/index.d.ts

@@ -3,3 +3,5 @@ export * from "./forex";
 export * from "./stocks";
 export * from "./indices";
 export * from "./commodities";
+export * from "./oi";
+export * from "./collateral";

package/lib/markets/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./forex"), exports);
 __exportStar(require("./stocks"), exports);
 __exportStar(require("./indices"), exports);
 __exportStar(require("./commodities"), exports);
+__exportStar(require("./oi"), exports);
+__exportStar(require("./collateral"), exports);

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

@@ -0,0 +1,63 @@
+/**
+ * @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
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+export declare const convertBeforeV10Collateral: (contractOi: IBorrowingFees.OpenInterestStructOutput, precision: number) => {
+    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,103 @@
+"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
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+const convertBeforeV10Collateral = (contractOi, precision) => {
+    return {
+        long: Number(contractOi.long) / precision,
+        short: Number(contractOi.short) / precision,
+    };
+};
+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) / collateralPrecision,
+        beforeV10Collateral: (0, exports.convertBeforeV10Collateral)(beforeV10, collateralPrecision),
+        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>>;