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

package/lib/trade/effectiveLeverage/getTradeNewEffectiveLeverage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @dev Trade effective leverage calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeNewEffectiveLeverage
+ */
+import { TradeEffectiveLeverageInput, TradeEffectiveLeverageContext, TradeEffectiveLeverageResult } from "./types";
+export type { TradeEffectiveLeverageInput, TradeEffectiveLeverageContext, TradeEffectiveLeverageResult, };
+export { buildTradeEffectiveLeverageContext } from "./builder";
+/**
+ * @dev Calculates the effective leverage of a trade accounting for unrealized PnL
+ * @dev Effective leverage increases when PnL is negative and decreases when positive
+ * @dev Mirrors contract's getTradeNewEffectiveLeverage function
+ * @param input Trade parameters including new position values
+ * @param context Combined context for calculations
+ * @returns Effective leverage and related values
+ */
+export declare const getTradeNewEffectiveLeverage: (input: TradeEffectiveLeverageInput, context: TradeEffectiveLeverageContext) => TradeEffectiveLeverageResult;
+/**
+ * @dev Simplified version for existing positions (no opening fees)
+ * @param input Trade parameters
+ * @param context Combined context
+ * @returns Effective leverage and related values
+ */
+export declare const getTradeEffectiveLeverage: (input: Omit<TradeEffectiveLeverageInput, "openingFeesCollateral">, context: TradeEffectiveLeverageContext) => TradeEffectiveLeverageResult;

package/lib/trade/effectiveLeverage/getTradeNewEffectiveLeverage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeEffectiveLeverage = exports.getTradeNewEffectiveLeverage = exports.buildTradeEffectiveLeverageContext = void 0;
+const __1 = require("..");
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildTradeEffectiveLeverageContext", { enumerable: true, get: function () { return builder_1.buildTradeEffectiveLeverageContext; } });
+/**
+ * @dev Calculates the effective leverage of a trade accounting for unrealized PnL
+ * @dev Effective leverage increases when PnL is negative and decreases when positive
+ * @dev Mirrors contract's getTradeNewEffectiveLeverage function
+ * @param input Trade parameters including new position values
+ * @param context Combined context for calculations
+ * @returns Effective leverage and related values
+ */
+const getTradeNewEffectiveLeverage = (input, context) => {
+    const { trade, newOpenPrice, newCollateralAmount, newLeverage, currentPairPrice, openingFeesCollateral, } = input;
+    const { closingPriceImpactContext } = context;
+    // Calculate new position size
+    const newPositionSize = newCollateralAmount * newLeverage;
+    // Calculate price impact for closing at current price
+    const closingPriceImpact = (0, __1.getTradeClosingPriceImpact)({
+        trade: Object.assign(Object.assign({}, trade), { openPrice: newOpenPrice, collateralAmount: newCollateralAmount, leverage: newLeverage }),
+        oraclePrice: currentPairPrice,
+        positionSizeCollateral: newPositionSize,
+        currentPairPrice: currentPairPrice,
+        useCumulativeVolPriceImpact: true,
+        collateralIndex: trade.collateralIndex,
+        pairIndex: trade.pairIndex,
+        pairSpreadP: context.baseSpreadP,
+        contractsVersion: closingPriceImpactContext.tradeInfo.contractsVersion,
+    }, closingPriceImpactContext);
+    // Calculate unrealized PnL
+    // For longs: (exitPrice - entryPrice) * positionSizeToken
+    // For shorts: (entryPrice - exitPrice) * positionSizeToken
+    const priceDiff = trade.long
+        ? closingPriceImpact.priceAfterImpact - newOpenPrice
+        : newOpenPrice - closingPriceImpact.priceAfterImpact;
+    const unrealizedPnl = priceDiff * closingPriceImpact.positionSizeToken;
+    // Calculate effective collateral (collateral + PnL - fees)
+    // Note: fees are subtracted because they reduce the effective collateral
+    const effectiveCollateral = newCollateralAmount + unrealizedPnl - openingFeesCollateral;
+    // Calculate effective leverage
+    // If effective collateral is <= 0, leverage is effectively infinite
+    const effectiveLeverage = effectiveCollateral > 0
+        ? newPositionSize / effectiveCollateral
+        : Number.MAX_SAFE_INTEGER;
+    return {
+        effectiveLeverage,
+        unrealizedPnl,
+        effectiveCollateral,
+        positionSize: newPositionSize,
+    };
+};
+exports.getTradeNewEffectiveLeverage = getTradeNewEffectiveLeverage;
+/**
+ * @dev Simplified version for existing positions (no opening fees)
+ * @param input Trade parameters
+ * @param context Combined context
+ * @returns Effective leverage and related values
+ */
+const getTradeEffectiveLeverage = (input, context) => {
+    return (0, exports.getTradeNewEffectiveLeverage)(Object.assign(Object.assign({}, input), { openingFeesCollateral: 0 }), context);
+};
+exports.getTradeEffectiveLeverage = getTradeEffectiveLeverage;

package/lib/trade/effectiveLeverage/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./builder";
+export { getTradeNewEffectiveLeverage, getTradeEffectiveLeverage, } from "./getTradeNewEffectiveLeverage";

package/lib/trade/effectiveLeverage/index.js

@@ -0,0 +1,22 @@
+"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 });
+exports.getTradeEffectiveLeverage = exports.getTradeNewEffectiveLeverage = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./builder"), exports);
+var getTradeNewEffectiveLeverage_1 = require("./getTradeNewEffectiveLeverage");
+Object.defineProperty(exports, "getTradeNewEffectiveLeverage", { enumerable: true, get: function () { return getTradeNewEffectiveLeverage_1.getTradeNewEffectiveLeverage; } });
+Object.defineProperty(exports, "getTradeEffectiveLeverage", { enumerable: true, get: function () { return getTradeNewEffectiveLeverage_1.getTradeEffectiveLeverage; } });

package/lib/trade/effectiveLeverage/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @dev Types for trade effective leverage calculations
+ */
+import { Trade, TradeClosingPriceImpactContext } from "..";
+/**
+ * @dev Input parameters for effective leverage calculation
+ * @dev Mirrors contract's parameters for getTradeNewEffectiveLeverage
+ */
+export type TradeEffectiveLeverageInput = {
+    trade: Trade;
+    newOpenPrice: number;
+    newCollateralAmount: number;
+    newLeverage: number;
+    currentPairPrice: number;
+    openingFeesCollateral: number;
+};
+/**
+ * @dev Context for effective leverage calculation
+ * Includes closing price impact context for PnL calculations
+ */
+export type TradeEffectiveLeverageContext = {
+    closingPriceImpactContext: TradeClosingPriceImpactContext;
+    baseSpreadP: number;
+};
+/**
+ * @dev Result of effective leverage calculation
+ */
+export type TradeEffectiveLeverageResult = {
+    effectiveLeverage: number;
+    unrealizedPnl: number;
+    effectiveCollateral: number;
+    positionSize: number;
+};

package/lib/trade/effectiveLeverage/types.js

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

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

@@ -4,18 +4,24 @@ export type GetBorrowingFeeContext = {
     currentBlock: number;
     groups: BorrowingFee.Group[];
     pairs: BorrowingFee.Pair[];
+    collateralPriceUsd: number;
 };
 /**
  * @dev Calculates borrowing fees using v1 model (block-based with groups)
  * @dev Still actively used by markets that haven't migrated to v2
+ * @dev Uses dynamic collateral OI - converts OI to USD for fee calculations
  * @param posDai Position size in collateral
- * @param pairIndex Trading pair index
+ * @param pairIndex Trading pair index (required)
  * @param long Whether position is long
  * @param initialAccFees Initial accumulated fees when trade was opened
- * @param context Context with current block and fee data
+ * @param context Context with current block, fee data, and collateral price
  * @returns Borrowing fee in collateral tokens
  */
-export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;
+export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex | undefined, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;
+/**
+ * @dev This function uses static OI which doesn't reflect current market values
+ * @dev The v10 contracts use dynamic OI (beforeV10 + afterV10Token * currentPrice)
+ */
 export declare const withinMaxGroupOi: (pairIndex: PairIndex, long: boolean, positionSizeCollateral: number, context: {
     groups: BorrowingFee.Group[];
     pairs: BorrowingFee.Pair[];
@@ -29,6 +35,7 @@ export declare const borrowingFeeUtils: {
     getPairPendingAccFees: (pairIndex: PairIndex, currentBlock: number, context: {
         pairs: BorrowingFee.Pair[];
         openInterest: OpenInterest;
+        collateralPriceUsd: number;
     }) => {
         accFeeLong: number;
         accFeeShort: number;
@@ -38,9 +45,11 @@ export declare const borrowingFeeUtils: {
     getPairPendingAccFee: (pairIndex: PairIndex, currentBlock: number, long: boolean, context: {
         pairs: BorrowingFee.Pair[];
         openInterest: OpenInterest;
+        collateralPriceUsd: number;
     }) => number;
     getGroupPendingAccFees: (groupIndex: number, currentBlock: number, context: {
         groups: BorrowingFee.Group[];
+        collateralPriceUsd: number;
     }) => {
         accFeeLong: number;
         accFeeShort: number;
@@ -49,8 +58,9 @@ export declare const borrowingFeeUtils: {
     };
     getGroupPendingAccFee: (groupIndex: number, currentBlock: number, long: boolean, context: {
         groups: BorrowingFee.Group[];
+        collateralPriceUsd: number;
     }) => number;
-    getPendingAccFees: (accFeeLong: number, accFeeShort: number, oiLong: number, oiShort: number, feePerBlock: number, currentBlock: number, accLastUpdatedBlock: number, maxOi: number, feeExponent: number, feeCaps?: BorrowingFee.BorrowingFeePerBlockCap) => {
+    getPendingAccFees: (accFeeLong: number, accFeeShort: number, oiLong: number, oiShort: number, feePerBlock: number, currentBlock: number, accLastUpdatedBlock: number, maxOi: number, feeExponent: number, feeCaps?: BorrowingFee.BorrowingFeePerBlockCap, collateralPriceUsd?: number) => {
         accFeeLong: number;
         accFeeShort: number;
         deltaLong: number;
@@ -66,3 +76,4 @@ export declare const borrowingFeeUtils: {
 };
 export * as BorrowingFee from "./types";
 export * from "./converter";
+export * from "./builder";

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

@@ -30,18 +30,22 @@ exports.BorrowingFee = exports.borrowingFeeUtils = exports.withinMaxGroupOi = ex
 /**
  * @dev Calculates borrowing fees using v1 model (block-based with groups)
  * @dev Still actively used by markets that haven't migrated to v2
+ * @dev Uses dynamic collateral OI - converts OI to USD for fee calculations
  * @param posDai Position size in collateral
- * @param pairIndex Trading pair index
+ * @param pairIndex Trading pair index (required)
  * @param long Whether position is long
  * @param initialAccFees Initial accumulated fees when trade was opened
- * @param context Context with current block and fee data
+ * @param context Context with current block, fee data, and collateral price
  * @returns Borrowing fee in collateral tokens
  */
 const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
-    if (!context.groups || !context.pairs || !context.pairs[pairIndex]) {
+    if (pairIndex === undefined) {
+        throw new Error("pairIndex is required for borrowing fee calculations");
+    }
+    const { pairs, groups } = context;
+    if (!groups || !pairs || !pairs[pairIndex]) {
         return 0;
     }
-    const { pairs } = context;
     const pairGroups = pairs[pairIndex].groups;
     const firstPairGroup = (pairGroups === null || pairGroups === void 0 ? void 0 : pairGroups.length) > 0 ? pairGroups[0] : undefined;
     let fee = 0;
@@ -52,13 +56,19 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
                 ? getPairPendingAccFee(pairIndex, context.currentBlock, long, {
                     pairs,
                     openInterest,
+                    collateralPriceUsd: context.collateralPriceUsd,
                 })
                 : long
                     ? firstPairGroup.pairAccFeeLong
                     : firstPairGroup.pairAccFeeShort) - initialAccFees.accPairFee;
     }
     for (let i = pairGroups.length; i > 0; i--) {
-        const { deltaGroup, deltaPair, beforeTradeOpen } = getPairGroupAccFeesDeltas(i - 1, pairGroups, initialAccFees, pairIndex, long, context);
+        const { deltaGroup, deltaPair, beforeTradeOpen } = getPairGroupAccFeesDeltas(i - 1, pairGroups, initialAccFees, pairIndex, long, {
+            currentBlock: context.currentBlock,
+            groups,
+            pairs,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
         fee += Math.max(deltaGroup, deltaPair);
         if (beforeTradeOpen) {
             break;
@@ -67,6 +77,10 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
     return (posDai * fee) / 100;
 };
 exports.getBorrowingFee = getBorrowingFee;
+/**
+ * @dev This function uses static OI which doesn't reflect current market values
+ * @dev The v10 contracts use dynamic OI (beforeV10 + afterV10Token * currentPrice)
+ */
 const withinMaxGroupOi = (pairIndex, long, positionSizeCollateral, context) => {
     const { groups, pairs } = context;
     if (!groups || !pairs) {
@@ -85,18 +99,19 @@ const getPairGroupIndex = (pairIndex, context) => {
     return pairGroups.length == 0 ? 0 : pairGroups[0].groupIndex;
 };
 const getPairPendingAccFees = (pairIndex, currentBlock, context) => {
-    const { pairs, openInterest: { long, short }, } = context;
+    const { pairs, openInterest: { long, short }, collateralPriceUsd, } = context;
     const pair = pairs[pairIndex];
-    return getPendingAccFees(pair.accFeeLong, pair.accFeeShort, long, short, pair.feePerBlock, currentBlock, pair.accLastUpdatedBlock, pair.oi.max, pair.feeExponent, pair.feePerBlockCap);
+    return getPendingAccFees(pair.accFeeLong, pair.accFeeShort, long, short, pair.feePerBlock, currentBlock, pair.accLastUpdatedBlock, pair.oi.max, pair.feeExponent, pair.feePerBlockCap, collateralPriceUsd);
 };
 const getPairPendingAccFee = (pairIndex, currentBlock, long, context) => {
     const { accFeeLong, accFeeShort } = getPairPendingAccFees(pairIndex, currentBlock, context);
     return long ? accFeeLong : accFeeShort;
 };
 const getGroupPendingAccFees = (groupIndex, currentBlock, context) => {
-    const { groups } = context;
+    const { groups, collateralPriceUsd } = context;
     const group = groups[groupIndex];
-    return getPendingAccFees(group.accFeeLong, group.accFeeShort, group.oi.long, group.oi.short, group.feePerBlock, currentBlock, group.accLastUpdatedBlock, group.oi.max, group.feeExponent);
+    return getPendingAccFees(group.accFeeLong, group.accFeeShort, group.oi.long, group.oi.short, group.feePerBlock, currentBlock, group.accLastUpdatedBlock, group.oi.max, group.feeExponent, undefined, // no fee caps for groups
+    collateralPriceUsd);
 };
 const getGroupPendingAccFee = (groupIndex, currentBlock, long, context) => {
     const { accFeeLong, accFeeShort } = getGroupPendingAccFees(groupIndex, currentBlock, context);
@@ -107,14 +122,16 @@ const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long,
     const beforeTradeOpen = group.block < initialFees.block;
     let deltaGroup, deltaPair;
     if (i == pairGroups.length - 1) {
-        const { currentBlock, groups, pairs } = context;
+        const { currentBlock, groups, pairs, collateralPriceUsd } = context;
         const openInterest = pairs[pairIndex].oi;
         deltaGroup = getGroupPendingAccFee(group.groupIndex, currentBlock, long, {
             groups,
+            collateralPriceUsd,
         });
         deltaPair = getPairPendingAccFee(pairIndex, currentBlock, long, {
             pairs,
             openInterest,
+            collateralPriceUsd,
         });
     }
     else {
@@ -137,8 +154,8 @@ const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long,
     }
     return { deltaGroup, deltaPair, beforeTradeOpen };
 };
-const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock, currentBlock, accLastUpdatedBlock, maxOi, feeExponent, feeCaps // as percentage: eg minP: 0.1 = 10%, maxP: 0.5 = 50%
-) => {
+const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock, currentBlock, accLastUpdatedBlock, maxOi, feeExponent, feeCaps, // as percentage: eg minP: 0.1 = 10%, maxP: 0.5 = 50%
+collateralPriceUsd) => {
     const moreShorts = oiLong < oiShort;
     const blockDistance = currentBlock > accLastUpdatedBlock ? currentBlock - accLastUpdatedBlock : 0;
     // If block distance is zero nothing changes
@@ -150,19 +167,25 @@ const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock
             deltaShort: 0,
         };
     }
-    const netOi = Math.abs(oiLong - oiShort);
-    // Calculate minimum and maximum effective oi
+    // Convert OI to USD if collateral price is provided (dynamic collateral OI)
+    const oiLongUsd = collateralPriceUsd ? oiLong * collateralPriceUsd : oiLong;
+    const oiShortUsd = collateralPriceUsd
+        ? oiShort * collateralPriceUsd
+        : oiShort;
+    const maxOiUsd = collateralPriceUsd ? maxOi * collateralPriceUsd : maxOi;
+    const netOi = Math.abs(oiLongUsd - oiShortUsd);
+    // Calculate minimum and maximum effective oi (using USD values if available)
     const { minP, maxP } = getFeePerBlockCaps(feeCaps);
-    const minNetOi = maxOi * minP;
-    const maxNetOi = maxOi * maxP;
+    const minNetOi = maxOiUsd * minP;
+    const maxNetOi = maxOiUsd * maxP;
     // Calculate the minimum acc fee delta (applies to both sides)
     const minDelta = minNetOi > 0
-        ? getPendingAccFeesDelta(blockDistance, feePerBlock, netOi, maxOi, feeExponent)
+        ? getPendingAccFeesDelta(blockDistance, feePerBlock, netOi, maxOiUsd, feeExponent)
         : 0;
     // Calculate the actual acc fee (using capped oi of 100% or less)
     const delta = netOi > minNetOi
         ? getPendingAccFeesDelta(blockDistance, feePerBlock, Math.min(netOi, maxNetOi), // if netOi > cap, use cap
-        maxOi, feeExponent)
+        maxOiUsd, feeExponent)
         : minDelta;
     const [deltaLong, deltaShort] = moreShorts
         ? [minDelta, delta]
@@ -217,3 +240,4 @@ exports.borrowingFeeUtils = {
 };
 exports.BorrowingFee = __importStar(require("./types"));
 __exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

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;

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

@@ -38,14 +38,13 @@ export declare const convertTradeInitialAccFees: (contractTradeData: IFundingFee
 export declare const convertTradeInitialAccFeesArray: (contractTradeDataArray: IFundingFees.TradeFeesDataStructOutput[]) => BorrowingFeeV2.TradeInitialAccFees[];
 /**
  * @dev Creates a context object from contract data arrays
- * @param collateralIndices Array of collateral indices
  * @param pairIndices Array of pair indices
  * @param borrowingParams Array of borrowing fee params from contract
  * @param borrowingData Array of pair borrowing fee data from contract
  * @param currentTimestamp Optional current timestamp
- * @returns Complete SDK context for borrowing v2 calculations
+ * @returns Complete SDK context for borrowing v2 calculations (collateral-scoped)
  */
-export declare const createBorrowingV2Context: (collateralIndices: number[], pairIndices: number[], borrowingParams: IFundingFees.BorrowingFeeParamsStructOutput[], borrowingData: IFundingFees.PairBorrowingFeeDataStructOutput[], currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;
+export declare const createBorrowingV2Context: (pairIndices: number[], borrowingParams: IFundingFees.BorrowingFeeParamsStructOutput[], borrowingData: IFundingFees.PairBorrowingFeeDataStructOutput[], currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;
 /**
  * @dev Helper function to validate borrowing rate per second
  * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
@@ -64,3 +63,13 @@ export declare const borrowingRateToAPR: (borrowingRatePerSecondP: number) => nu
  * @returns Borrowing rate per second (normalized float)
  */
 export declare const aprToBorrowingRate: (aprPercentage: number) => number;
+/**
+ * @dev Creates a collateral-scoped context from frontend data structure
+ * @param collateralBorrowingData Data structure from frontend (params and data arrays)
+ * @param currentTimestamp Optional current timestamp
+ * @returns Collateral-scoped borrowing fee v2 context
+ */
+export declare const createCollateralScopedBorrowingContext: (collateralBorrowingData: {
+    params: BorrowingFeeV2.BorrowingFeeParams[];
+    data: BorrowingFeeV2.PairBorrowingFeeData[];
+}, currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aprToBorrowingRate = exports.borrowingRateToAPR = exports.isValidBorrowingRate = exports.createBorrowingV2Context = exports.convertTradeInitialAccFeesArray = exports.convertTradeInitialAccFees = exports.convertPairBorrowingFeeDataArray = exports.convertPairBorrowingFeeData = exports.convertBorrowingFeeParamsArray = exports.convertBorrowingFeeParams = void 0;
+exports.createCollateralScopedBorrowingContext = exports.aprToBorrowingRate = exports.borrowingRateToAPR = exports.isValidBorrowingRate = exports.createBorrowingV2Context = exports.convertTradeInitialAccFeesArray = exports.convertTradeInitialAccFees = exports.convertPairBorrowingFeeDataArray = exports.convertPairBorrowingFeeData = exports.convertBorrowingFeeParamsArray = exports.convertBorrowingFeeParams = void 0;
 const index_1 = require("./index");
 /**
  * @dev Converts contract BorrowingFeeParams to SDK type
@@ -56,35 +56,24 @@ const convertTradeInitialAccFeesArray = (contractTradeDataArray) => contractTrad
 exports.convertTradeInitialAccFeesArray = convertTradeInitialAccFeesArray;
 /**
  * @dev Creates a context object from contract data arrays
- * @param collateralIndices Array of collateral indices
  * @param pairIndices Array of pair indices
  * @param borrowingParams Array of borrowing fee params from contract
  * @param borrowingData Array of pair borrowing fee data from contract
  * @param currentTimestamp Optional current timestamp
- * @returns Complete SDK context for borrowing v2 calculations
+ * @returns Complete SDK context for borrowing v2 calculations (collateral-scoped)
  */
-const createBorrowingV2Context = (collateralIndices, pairIndices, borrowingParams, borrowingData, currentTimestamp) => {
+const createBorrowingV2Context = (pairIndices, borrowingParams, borrowingData, currentTimestamp) => {
     const context = {
         currentTimestamp,
         borrowingParams: {},
         borrowingData: {},
     };
-    // Build nested objects indexed by collateralIndex and pairIndex
-    for (let i = 0; i < collateralIndices.length; i++) {
-        const collateralIndex = collateralIndices[i];
+    // Build objects indexed by pairIndex
+    for (let i = 0; i < pairIndices.length; i++) {
         const pairIndex = pairIndices[i];
-        // Initialize collateral index objects if they don't exist
-        if (!context.borrowingParams[collateralIndex]) {
-            context.borrowingParams[collateralIndex] = {};
-        }
-        if (!context.borrowingData[collateralIndex]) {
-            context.borrowingData[collateralIndex] = {};
-        }
         // Store converted data
-        context.borrowingParams[collateralIndex][pairIndex] =
-            (0, exports.convertBorrowingFeeParams)(borrowingParams[i]);
-        context.borrowingData[collateralIndex][pairIndex] =
-            (0, exports.convertPairBorrowingFeeData)(borrowingData[i]);
+        context.borrowingParams[pairIndex] = (0, exports.convertBorrowingFeeParams)(borrowingParams[i]);
+        context.borrowingData[pairIndex] = (0, exports.convertPairBorrowingFeeData)(borrowingData[i]);
     }
     return context;
 };
@@ -119,3 +108,25 @@ const aprToBorrowingRate = (aprPercentage) => {
     return aprPercentage / SECONDS_PER_YEAR;
 };
 exports.aprToBorrowingRate = aprToBorrowingRate;
+/**
+ * @dev Creates a collateral-scoped context from frontend data structure
+ * @param collateralBorrowingData Data structure from frontend (params and data arrays)
+ * @param currentTimestamp Optional current timestamp
+ * @returns Collateral-scoped borrowing fee v2 context
+ */
+const createCollateralScopedBorrowingContext = (collateralBorrowingData, currentTimestamp) => {
+    const context = {
+        currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000),
+        borrowingParams: {},
+        borrowingData: {},
+    };
+    // Map arrays to objects indexed by array position (pairIndex)
+    collateralBorrowingData.params.forEach((param, index) => {
+        context.borrowingParams[index] = param;
+    });
+    collateralBorrowingData.data.forEach((data, index) => {
+        context.borrowingData[index] = data;
+    });
+    return context;
+};
+exports.createCollateralScopedBorrowingContext = createCollateralScopedBorrowingContext;

package/lib/{contracts/fetch/fees/borrowingFeesV2.d.ts → trade/fees/borrowingV2/fetcher.d.ts}

@@ -1,6 +1,5 @@
-/// <reference types="mocha" />
-import type { GNSMultiCollatDiamond } from "../../types/generated";
-import { BorrowingFeeV2 } from "../../../trade/fees/borrowingV2";
+import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
+import { BorrowingFeeV2 } from ".";
 /**
  * @dev Fetches borrowing fee parameters v2 for specific pairs
  * @param contract GNSMultiCollatDiamond contract instance

package/lib/{contracts/fetch/fees/borrowingFeesV2.js → trade/fees/borrowingV2/fetcher.js}

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchBorrowingV2DataForPairs = exports.createBorrowingV2ContextFromArrays = exports.createBorrowingV2ContextFromContract = exports.fetchAllBorrowingV2Data = exports.fetchPairPendingAccBorrowingFeesV2 = exports.fetchTradeBorrowingFeesCollateralV2 = exports.fetchPairBorrowingFeeDataV2 = exports.fetchBorrowingFeeParamsV2 = void 0;
-const converter_1 = require("../../../trade/fees/borrowingV2/converter");
+const converter_1 = require("./converter");
 /**
  * @dev Fetches borrowing fee parameters v2 for specific pairs
  * @param contract GNSMultiCollatDiamond contract instance
@@ -147,20 +147,12 @@ const createBorrowingV2ContextFromArrays = (collateralIndices, pairIndices, para
         borrowingParams: {},
         borrowingData: {},
     };
-    // Build nested objects indexed by collateralIndex and pairIndex
-    for (let i = 0; i < collateralIndices.length; i++) {
-        const collateralIndex = collateralIndices[i];
+    // Build objects indexed by pairIndex (collateral-scoped)
+    for (let i = 0; i < pairIndices.length; i++) {
         const pairIndex = pairIndices[i];
-        // Initialize collateral index objects if they don't exist
-        if (!context.borrowingParams[collateralIndex]) {
-            context.borrowingParams[collateralIndex] = {};
-        }
-        if (!context.borrowingData[collateralIndex]) {
-            context.borrowingData[collateralIndex] = {};
-        }
-        // Store data
-        context.borrowingParams[collateralIndex][pairIndex] = params[i];
-        context.borrowingData[collateralIndex][pairIndex] = data[i];
+        // Store data indexed by pairIndex
+        context.borrowingParams[pairIndex] = params[i];
+        context.borrowingData[pairIndex] = data[i];
     }
     return context;
 };

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

@@ -22,23 +22,11 @@ export declare const BORROWING_V2_PRECISION: {
 export declare const getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
 /**
  * @dev Calculates borrowing fees owed by a specific trade
- * @param input Trade borrowing fee calculation input
- * @param context Context containing borrowing parameters and data
- * @returns Borrowing fees in collateral tokens
- */
-export declare const getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
-/**
- * @dev Convenience function to calculate borrowing fees for a trade using individual parameters
- * @param positionSizeCollateral Position size in collateral tokens
- * @param pairIndex Index of the trading pair
- * @param collateralIndex Index of the collateral
- * @param openPrice Price at which the trade was opened
- * @param currentPairPrice Current price of the trading pair
- * @param initialAccBorrowingFeeP Initial accumulated borrowing fee when trade was opened
- * @param context Context containing borrowing parameters and data
+ * @param input Trade borrowing fee calculation input (without pairIndex)
+ * @param context Pair-specific borrowing context
  * @returns Borrowing fees in collateral tokens
  */
-export declare const getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+export declare const getTradeBorrowingFeesCollateral: (input: Omit<BorrowingFeeV2.TradeBorrowingFeeInput, "pairIndex">, context: BorrowingFeeV2.GetPairBorrowingFeeV2Context) => number;
 /**
  * @dev Utility function to get pending accumulated borrowing fees for a pair using context
  * @param input Pair borrowing fee calculation input
@@ -51,9 +39,10 @@ export declare const getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingF
  */
 export declare const borrowingFeeV2Utils: {
     getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
-    getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+    getTradeBorrowingFeesCollateral: (input: Omit<BorrowingFeeV2.TradeBorrowingFeeInput, "pairIndex">, context: BorrowingFeeV2.GetPairBorrowingFeeV2Context) => number;
     getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
-    getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
 };
 export * as BorrowingFeeV2 from "./types";
+export { GetPairBorrowingFeeV2Context } from "./types";
 export * from "./converter";
+export * from "./fetcher";