@gainsnetwork/sdk 0.0.0-me-rc1

package/lib/trade/effectiveLeverage/getTradeNewEffectiveLeverage.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeEffectiveLeverage = exports.getTradeNewEffectiveLeverage = void 0;
+/**
+ * @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
+ * @returns Effective leverage and related values
+ */
+const getTradeNewEffectiveLeverage = (input) => {
+    const { newOpenPrice, newCollateralAmount, newLeverage, currentPairPrice, tradeValueCollateral, } = input;
+    // Calculate new position size
+    const newPositionSize = newCollateralAmount * newLeverage;
+    // Calculate dynamic position size (matching on-chain logic)
+    // This adjusts position size based on current price vs open price
+    const newPosSizeCollateralDynamic = (newPositionSize * currentPairPrice) / newOpenPrice;
+    // Use the provided trade value as margin value
+    // This already includes collateral + PnL with price impact - fees
+    const newMarginValueCollateral = tradeValueCollateral;
+    // Calculate effective leverage (matching on-chain)
+    // If margin value is <= 0, leverage is effectively infinite
+    const effectiveLeverage = newMarginValueCollateral > 0
+        ? newPosSizeCollateralDynamic / newMarginValueCollateral
+        : Number.MAX_SAFE_INTEGER;
+    return {
+        effectiveLeverage,
+        unrealizedPnl: tradeValueCollateral - newCollateralAmount,
+        effectiveCollateral: newMarginValueCollateral,
+        positionSize: newPositionSize,
+    };
+};
+exports.getTradeNewEffectiveLeverage = getTradeNewEffectiveLeverage;
+/**
+ * @dev Simplified version for existing positions
+ * @param input Trade parameters
+ * @returns Effective leverage and related values
+ */
+const getTradeEffectiveLeverage = (input) => {
+    return (0, exports.getTradeNewEffectiveLeverage)(input);
+};
+exports.getTradeEffectiveLeverage = getTradeEffectiveLeverage;

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

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

package/lib/trade/effectiveLeverage/index.js

@@ -0,0 +1,21 @@
+"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);
+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,30 @@
+/**
+ * @dev Types for trade effective leverage calculations
+ */
+import { Trade } 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;
+    tradeValueCollateral: number;
+};
+/**
+ * @dev Context for effective leverage calculation
+ * Simplified context since price impact is now included in tradeValueCollateral
+ */
+export type TradeEffectiveLeverageContext = {};
+/**
+ * @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) => {
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!collateral?.pairBorrowingFees || !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: collateral.prices?.collateralPriceUsd || 1,
+        pairOis: collateral.pairOis,
+    };
+};
+exports.buildBorrowingV1Context = buildBorrowingV1Context;

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

@@ -0,0 +1,17 @@
+import { IBorrowingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { BorrowingFee } from ".";
+export declare const convertPairGroupBorrowingFee: (pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput) => BorrowingFee.PairGroup;
+export declare const convertPairBorrowingFee: (pair: IBorrowingFees.BorrowingDataStructOutput, pairOi: IBorrowingFees.OpenInterestStructOutput, pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput[], feeCap: IBorrowingFees.BorrowingFeePerBlockCapStructOutput) => BorrowingFee.Pair;
+export declare const convertPairBorrowingFees: ([pairs, pairOi, pairGroups, feeCaps]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[],
+    IBorrowingFees.BorrowingPairGroupStructOutput[][],
+    IBorrowingFees.BorrowingFeePerBlockCapStructOutput[]
+]) => BorrowingFee.Pair[];
+export declare const convertGroupBorrowingFee: (group: IBorrowingFees.BorrowingDataStructOutput, groupOi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.Group;
+export declare const convertGroupBorrowingData: (obj: IBorrowingFees.BorrowingDataStructOutput, oi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.BorrowingData & BorrowingFee.BorrowingOi;
+export declare const convertGroupBorrowingFees: ([groups, groupOis]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[]
+]) => BorrowingFee.Group[];
+export declare const convertFeePerBlockCap: (feeCap: IBorrowingFees.BorrowingFeePerBlockCapStructOutput) => BorrowingFee.BorrowingFeePerBlockCap;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFeePerBlockCap = exports.convertGroupBorrowingFees = exports.convertGroupBorrowingData = exports.convertGroupBorrowingFee = exports.convertPairBorrowingFees = exports.convertPairBorrowingFee = exports.convertPairGroupBorrowingFee = void 0;
+const borrowingFees_1 = require("../../../contracts/utils/borrowingFees");
+const convertPairGroupBorrowingFee = (pairGroup) => ({
+    groupIndex: pairGroup.groupIndex,
+    name: (0, borrowingFees_1.getBorrowingGroupName)(pairGroup.groupIndex),
+    initialAccFeeLong: parseFloat(pairGroup.initialAccFeeLong.toString()) / 1e10,
+    initialAccFeeShort: parseFloat(pairGroup.initialAccFeeShort.toString()) / 1e10,
+    prevGroupAccFeeLong: parseFloat(pairGroup.prevGroupAccFeeLong.toString()) / 1e10,
+    prevGroupAccFeeShort: parseFloat(pairGroup.prevGroupAccFeeShort.toString()) / 1e10,
+    pairAccFeeLong: parseFloat(pairGroup.pairAccFeeLong.toString()) / 1e10,
+    pairAccFeeShort: parseFloat(pairGroup.pairAccFeeShort.toString()) / 1e10,
+    block: pairGroup.block,
+});
+exports.convertPairGroupBorrowingFee = convertPairGroupBorrowingFee;
+const convertPairBorrowingFee = (pair, pairOi, pairGroup, feeCap) => ({
+    ...(0, exports.convertGroupBorrowingData)(pair, pairOi),
+    groups: pairGroup.map(value => (0, exports.convertPairGroupBorrowingFee)(value)),
+    feePerBlockCap: (0, exports.convertFeePerBlockCap)(feeCap),
+});
+exports.convertPairBorrowingFee = convertPairBorrowingFee;
+const convertPairBorrowingFees = ([pairs, pairOi, pairGroups, feeCaps]) => pairs.map((value, ix) => (0, exports.convertPairBorrowingFee)(value, pairOi[ix], pairGroups[ix], feeCaps[ix]));
+exports.convertPairBorrowingFees = convertPairBorrowingFees;
+const convertGroupBorrowingFee = (group, groupOi) => (0, exports.convertGroupBorrowingData)(group, groupOi);
+exports.convertGroupBorrowingFee = convertGroupBorrowingFee;
+const convertGroupBorrowingData = (obj, oi) => ({
+    oi: {
+        long: parseFloat(oi.long.toString()) / 1e10,
+        short: parseFloat(oi.short.toString()) / 1e10,
+        max: parseFloat(oi.max.toString()) / 1e10,
+    },
+    feePerBlock: obj.feePerBlock / 1e10,
+    accFeeLong: parseFloat(obj.accFeeLong.toString()) / 1e10,
+    accFeeShort: parseFloat(obj.accFeeShort.toString()) / 1e10,
+    accLastUpdatedBlock: obj.accLastUpdatedBlock,
+    feeExponent: obj.feeExponent,
+});
+exports.convertGroupBorrowingData = convertGroupBorrowingData;
+const convertGroupBorrowingFees = ([groups, groupOis]) => groups.map((value, ix) => (0, exports.convertGroupBorrowingFee)(value, groupOis[ix]));
+exports.convertGroupBorrowingFees = convertGroupBorrowingFees;
+const convertFeePerBlockCap = (feeCap) => ({
+    minP: feeCap.minP ? parseFloat(feeCap.minP.toString()) / 1e3 / 100 : 0,
+    maxP: feeCap.maxP ? parseFloat(feeCap.maxP.toString()) / 1e3 / 100 : 1,
+});
+exports.convertFeePerBlockCap = convertFeePerBlockCap;

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

@@ -0,0 +1,81 @@
+import { UnifiedPairOi } from "../../..";
+import { OpenInterest, PairIndex } from "../../types";
+import * as BorrowingFee from "./types";
+export type GetBorrowingFeeContext = {
+    currentBlock: number;
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+    collateralPriceUsd: number;
+    pairOis: UnifiedPairOi[];
+};
+/**
+ * @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 (required)
+ * @param long Whether position is long
+ * @param initialAccFees Initial accumulated fees when trade was opened
+ * @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 | undefined, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, currentPairPrice: number, 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[];
+}) => boolean;
+export declare const borrowingFeeUtils: {
+    getPairGroupAccFeesDeltas: (i: number, pairGroups: BorrowingFee.PairGroup[], initialFees: BorrowingFee.InitialAccFees, pairIndex: PairIndex, long: boolean, currentPairPrice: number, context: GetBorrowingFeeContext) => {
+        deltaGroup: number;
+        deltaPair: number;
+        beforeTradeOpen: boolean;
+    };
+    getPairPendingAccFees: (pairIndex: PairIndex, currentBlock: number, context: {
+        pairs: BorrowingFee.Pair[];
+        openInterest: OpenInterest;
+        collateralPriceUsd: number;
+    }) => {
+        accFeeLong: number;
+        accFeeShort: number;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    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;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    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, collateralPriceUsd?: number) => {
+        accFeeLong: number;
+        accFeeShort: number;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    getActiveFeePerBlock: (pair: BorrowingFee.Pair, group: BorrowingFee.Group | undefined) => number;
+    getBorrowingDataActiveFeePerBlock: (val: BorrowingFee.Pair | BorrowingFee.Group) => number;
+    getPairGroupIndex: (pairIndex: PairIndex, context: {
+        pairs: BorrowingFee.Pair[];
+    }) => number;
+    getPendingAccFeesDelta: (blockDistance: number, feePerBlock: number, netOi: number, maxOi: number, feeExponent: number) => number;
+    getFeePerBlockCaps: (cap?: BorrowingFee.BorrowingFeePerBlockCap) => BorrowingFee.BorrowingFeePerBlockCap;
+};
+export * as BorrowingFee from "./types";
+export * from "./converter";
+export * from "./builder";

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

@@ -0,0 +1,259 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.BorrowingFee = exports.borrowingFeeUtils = exports.withinMaxGroupOi = exports.getBorrowingFee = void 0;
+const __1 = require("../../..");
+/**
+ * @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 (required)
+ * @param long Whether position is long
+ * @param initialAccFees Initial accumulated fees when trade was opened
+ * @param context Context with current block, fee data, and collateral price
+ * @returns Borrowing fee in collateral tokens
+ */
+const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, currentPairPrice, context) => {
+    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 pairGroups = pairs[pairIndex].groups;
+    const firstPairGroup = pairGroups?.length > 0 ? pairGroups[0] : undefined;
+    let fee = 0;
+    if (!firstPairGroup || firstPairGroup.block > initialAccFees.block) {
+        const openInterest = (0, __1.getPairTotalOisDynamicCollateral)(pairIndex, {
+            pairOis: context.pairOis,
+            currentPairPrice,
+        });
+        fee =
+            (!firstPairGroup
+                ? getPairPendingAccFee(pairIndex, context.currentBlock, long, {
+                    pairs,
+                    openInterest: {
+                        long: openInterest.long,
+                        short: openInterest.short,
+                        max: context.pairOis[pairIndex].maxCollateral,
+                    },
+                    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, currentPairPrice, {
+            currentBlock: context.currentBlock,
+            groups,
+            pairs,
+            collateralPriceUsd: context.collateralPriceUsd,
+            pairOis: context.pairOis,
+        });
+        fee += Math.max(deltaGroup, deltaPair);
+        if (beforeTradeOpen) {
+            break;
+        }
+    }
+    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) {
+        return false;
+    }
+    const g = groups[getPairGroupIndex(pairIndex, { pairs })].oi;
+    return (g.max == 0 || (long ? g.long : g.short) + positionSizeCollateral <= g.max);
+};
+exports.withinMaxGroupOi = withinMaxGroupOi;
+const getPairGroupIndex = (pairIndex, context) => {
+    const { pairs } = context;
+    if (!pairs[pairIndex]) {
+        return 0;
+    }
+    const pairGroups = pairs[pairIndex].groups;
+    return pairGroups.length == 0 ? 0 : pairGroups[0].groupIndex;
+};
+const getPairPendingAccFees = (pairIndex, currentBlock, 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, context.openInterest.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, 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, undefined, // no fee caps for groups
+    collateralPriceUsd);
+};
+const getGroupPendingAccFee = (groupIndex, currentBlock, long, context) => {
+    const { accFeeLong, accFeeShort } = getGroupPendingAccFees(groupIndex, currentBlock, context);
+    return long ? accFeeLong : accFeeShort;
+};
+const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long, currentPairPrice, context) => {
+    const group = pairGroups[i];
+    const beforeTradeOpen = group.block < initialFees.block;
+    let deltaGroup, deltaPair;
+    if (i == pairGroups.length - 1) {
+        const { currentBlock, groups, pairs, collateralPriceUsd } = context;
+        const openInterest = (0, __1.getPairTotalOisDynamicCollateral)(pairIndex, {
+            pairOis: context.pairOis,
+            currentPairPrice,
+        });
+        deltaGroup = getGroupPendingAccFee(group.groupIndex, currentBlock, long, {
+            groups,
+            collateralPriceUsd,
+        });
+        deltaPair = getPairPendingAccFee(pairIndex, currentBlock, long, {
+            pairs,
+            openInterest: {
+                long: openInterest.long,
+                short: openInterest.short,
+                max: context.pairOis[pairIndex].maxCollateral,
+            },
+            collateralPriceUsd,
+        });
+    }
+    else {
+        const nextGroup = pairGroups[i + 1];
+        if (beforeTradeOpen && nextGroup.block <= initialFees.block) {
+            return { deltaGroup: 0, deltaPair: 0, beforeTradeOpen };
+        }
+        deltaGroup = long
+            ? nextGroup.prevGroupAccFeeLong
+            : nextGroup.prevGroupAccFeeShort;
+        deltaPair = long ? nextGroup.pairAccFeeLong : nextGroup.pairAccFeeShort;
+    }
+    if (beforeTradeOpen) {
+        deltaGroup -= initialFees.accGroupFee;
+        deltaPair -= initialFees.accPairFee;
+    }
+    else {
+        deltaGroup -= long ? group.initialAccFeeLong : group.initialAccFeeShort;
+        deltaPair -= long ? group.pairAccFeeLong : group.pairAccFeeShort;
+    }
+    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%
+collateralPriceUsd) => {
+    const moreShorts = oiLong < oiShort;
+    const blockDistance = currentBlock > accLastUpdatedBlock ? currentBlock - accLastUpdatedBlock : 0;
+    // If block distance is zero nothing changes
+    if (blockDistance === 0) {
+        return {
+            accFeeLong,
+            accFeeShort,
+            deltaLong: 0,
+            deltaShort: 0,
+        };
+    }
+    // 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 = maxOiUsd * minP;
+    const maxNetOi = maxOiUsd * maxP;
+    // Calculate the minimum acc fee delta (applies to both sides)
+    const minDelta = minNetOi > 0
+        ? getPendingAccFeesDelta(blockDistance, feePerBlock, minNetOi, 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
+        maxOiUsd, feeExponent)
+        : minDelta;
+    const [deltaLong, deltaShort] = moreShorts
+        ? [minDelta, delta]
+        : [delta, minDelta];
+    return {
+        accFeeLong: accFeeLong + deltaLong,
+        accFeeShort: accFeeShort + deltaShort,
+        deltaLong,
+        deltaShort,
+    };
+};
+const getPendingAccFeesDelta = (blockDistance, feePerBlock, netOi, maxOi, feeExponent) => {
+    return maxOi > 0 && feeExponent > 0
+        ? feePerBlock * blockDistance * (netOi / maxOi) ** feeExponent
+        : 0;
+};
+const getFeePerBlockCaps = (cap) => {
+    return {
+        minP: cap?.minP || 0,
+        maxP: cap?.maxP && cap.maxP > 0 ? cap.maxP : 1,
+    };
+};
+const getBorrowingDataActiveFeePerBlock = (val) => {
+    const { long, short, max } = val.oi;
+    const { minP, maxP } = getFeePerBlockCaps("feePerBlockCap" in val ? val.feePerBlockCap : undefined);
+    // Calculate the effective open interest
+    // If minP > 0 then netOi has to be at least minP * maxOi
+    // If maxP > 0 then netOi cannot be more than maxP * maxOi
+    const effectiveOi = Math.min(Math.max(Math.abs(long - short), max * minP), max * maxP);
+    return val.feePerBlock * (effectiveOi / max) ** val.feeExponent;
+};
+const getActiveFeePerBlock = (pair, group) => {
+    const pairFeePerBlock = getBorrowingDataActiveFeePerBlock(pair);
+    if (!group) {
+        return pairFeePerBlock;
+    }
+    const groupFeePerBlock = getBorrowingDataActiveFeePerBlock(group);
+    return Math.max(pairFeePerBlock, groupFeePerBlock);
+};
+exports.borrowingFeeUtils = {
+    getPairGroupAccFeesDeltas,
+    getPairPendingAccFees,
+    getPairPendingAccFee,
+    getGroupPendingAccFees,
+    getGroupPendingAccFee,
+    getPendingAccFees,
+    getActiveFeePerBlock,
+    getBorrowingDataActiveFeePerBlock,
+    getPairGroupIndex,
+    getPendingAccFeesDelta,
+    getFeePerBlockCaps,
+};
+exports.BorrowingFee = __importStar(require("./types"));
+__exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,36 @@
+import { OpenInterest } from "../../types";
+export type BorrowingData = {
+    feePerBlock: number;
+    accFeeLong: number;
+    accFeeShort: number;
+    accLastUpdatedBlock: number;
+    feeExponent: number;
+};
+export type PairGroup = {
+    groupIndex: number;
+    name?: string;
+    block: number;
+    initialAccFeeLong: number;
+    initialAccFeeShort: number;
+    prevGroupAccFeeLong: number;
+    prevGroupAccFeeShort: number;
+    pairAccFeeLong: number;
+    pairAccFeeShort: number;
+};
+export type BorrowingOi = {
+    oi: OpenInterest;
+};
+export type BorrowingFeePerBlockCap = {
+    minP: number;
+    maxP: number;
+};
+export type Pair = BorrowingData & BorrowingOi & {
+    groups: PairGroup[];
+    feePerBlockCap?: BorrowingFeePerBlockCap;
+};
+export type Group = BorrowingData & BorrowingOi;
+export type InitialAccFees = {
+    accPairFee: number;
+    accGroupFee: number;
+    block: number;
+};

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

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

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,23 @@
+"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) => {
+    const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
+    if (!collateral?.pairBorrowingFeesV2) {
+        return undefined;
+    }
+    const params = collateral.pairBorrowingFeesV2.params?.[pairIndex];
+    const data = collateral.pairBorrowingFeesV2.data?.[pairIndex];
+    if (!params || !data) {
+        return undefined;
+    }
+    return {
+        params,
+        data,
+        currentTimestamp,
+    };
+};
+exports.buildBorrowingV2Context = buildBorrowingV2Context;