@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc1

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

@@ -27,11 +27,25 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BorrowingFee = exports.borrowingFeeUtils = exports.withinMaxGroupOi = exports.getBorrowingFee = void 0;
+/**
+ * @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, 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;
@@ -42,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;
@@ -57,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) {
@@ -75,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);
@@ -97,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 {
@@ -127,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
@@ -140,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]
@@ -207,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

@@ -0,0 +1,75 @@
+import type { IFundingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { BorrowingFeeV2 } from ".";
+/**
+ * @dev Converts contract BorrowingFeeParams to SDK type
+ * @param contractParams Contract borrowing fee params from IFundingFees.BorrowingFeeParams
+ * @returns SDK BorrowingFeeParams
+ */
+export declare const convertBorrowingFeeParams: (contractParams: IFundingFees.BorrowingFeeParamsStructOutput) => BorrowingFeeV2.BorrowingFeeParams;
+/**
+ * @dev Converts array of contract BorrowingFeeParams to SDK types
+ * @param contractParamsArray Array of contract borrowing fee params
+ * @returns Array of SDK BorrowingFeeParams
+ */
+export declare const convertBorrowingFeeParamsArray: (contractParamsArray: IFundingFees.BorrowingFeeParamsStructOutput[]) => BorrowingFeeV2.BorrowingFeeParams[];
+/**
+ * @dev Converts contract PairBorrowingFeeData to SDK type
+ * @param contractData Contract pair borrowing fee data from IFundingFees.PairBorrowingFeeData
+ * @returns SDK PairBorrowingFeeData
+ */
+export declare const convertPairBorrowingFeeData: (contractData: IFundingFees.PairBorrowingFeeDataStructOutput) => BorrowingFeeV2.PairBorrowingFeeData;
+/**
+ * @dev Converts array of contract PairBorrowingFeeData to SDK types
+ * @param contractDataArray Array of contract pair borrowing fee data
+ * @returns Array of SDK PairBorrowingFeeData
+ */
+export declare const convertPairBorrowingFeeDataArray: (contractDataArray: IFundingFees.PairBorrowingFeeDataStructOutput[]) => BorrowingFeeV2.PairBorrowingFeeData[];
+/**
+ * @dev Converts contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeData Contract trade fees data from IFundingFees.TradeFeesData
+ * @returns SDK TradeInitialAccFees
+ */
+export declare const convertTradeInitialAccFees: (contractTradeData: IFundingFees.TradeFeesDataStructOutput) => BorrowingFeeV2.TradeInitialAccFees;
+/**
+ * @dev Converts array of contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeDataArray Array of contract trade fees data
+ * @returns Array of SDK TradeInitialAccFees
+ */
+export declare const convertTradeInitialAccFeesArray: (contractTradeDataArray: IFundingFees.TradeFeesDataStructOutput[]) => BorrowingFeeV2.TradeInitialAccFees[];
+/**
+ * @dev Creates a context object from contract data arrays
+ * @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 (collateral-scoped)
+ */
+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)
+ * @returns True if rate is within valid bounds
+ */
+export declare const isValidBorrowingRate: (borrowingRatePerSecondP: number) => boolean;
+/**
+ * @dev Helper function to convert borrowing rate to APR percentage
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns APR as percentage (e.g., 10.5 for 10.5% APR)
+ */
+export declare const borrowingRateToAPR: (borrowingRatePerSecondP: number) => number;
+/**
+ * @dev Helper function to convert APR percentage to borrowing rate per second
+ * @param aprPercentage APR as percentage (e.g., 10.5 for 10.5% APR)
+ * @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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ * @param contractParams Contract borrowing fee params from IFundingFees.BorrowingFeeParams
+ * @returns SDK BorrowingFeeParams
+ */
+const convertBorrowingFeeParams = (contractParams) => ({
+    borrowingRatePerSecondP: contractParams.borrowingRatePerSecondP /
+        index_1.BORROWING_V2_PRECISION.RATE_PER_SECOND,
+});
+exports.convertBorrowingFeeParams = convertBorrowingFeeParams;
+/**
+ * @dev Converts array of contract BorrowingFeeParams to SDK types
+ * @param contractParamsArray Array of contract borrowing fee params
+ * @returns Array of SDK BorrowingFeeParams
+ */
+const convertBorrowingFeeParamsArray = (contractParamsArray) => contractParamsArray.map(params => (0, exports.convertBorrowingFeeParams)(params));
+exports.convertBorrowingFeeParamsArray = convertBorrowingFeeParamsArray;
+/**
+ * @dev Converts contract PairBorrowingFeeData to SDK type
+ * @param contractData Contract pair borrowing fee data from IFundingFees.PairBorrowingFeeData
+ * @returns SDK PairBorrowingFeeData
+ */
+const convertPairBorrowingFeeData = (contractData) => ({
+    accBorrowingFeeP: parseFloat(contractData.accBorrowingFeeP.toString()) /
+        index_1.BORROWING_V2_PRECISION.ACC_FEE,
+    lastBorrowingUpdateTs: contractData.lastBorrowingUpdateTs,
+});
+exports.convertPairBorrowingFeeData = convertPairBorrowingFeeData;
+/**
+ * @dev Converts array of contract PairBorrowingFeeData to SDK types
+ * @param contractDataArray Array of contract pair borrowing fee data
+ * @returns Array of SDK PairBorrowingFeeData
+ */
+const convertPairBorrowingFeeDataArray = (contractDataArray) => contractDataArray.map(data => (0, exports.convertPairBorrowingFeeData)(data));
+exports.convertPairBorrowingFeeDataArray = convertPairBorrowingFeeDataArray;
+/**
+ * @dev Converts contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeData Contract trade fees data from IFundingFees.TradeFeesData
+ * @returns SDK TradeInitialAccFees
+ */
+const convertTradeInitialAccFees = (contractTradeData) => ({
+    initialAccBorrowingFeeP: parseFloat(contractTradeData.initialAccBorrowingFeeP.toString()) /
+        index_1.BORROWING_V2_PRECISION.ACC_FEE,
+});
+exports.convertTradeInitialAccFees = convertTradeInitialAccFees;
+/**
+ * @dev Converts array of contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeDataArray Array of contract trade fees data
+ * @returns Array of SDK TradeInitialAccFees
+ */
+const convertTradeInitialAccFeesArray = (contractTradeDataArray) => contractTradeDataArray.map(data => (0, exports.convertTradeInitialAccFees)(data));
+exports.convertTradeInitialAccFeesArray = convertTradeInitialAccFeesArray;
+/**
+ * @dev Creates a context object from contract data arrays
+ * @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 (collateral-scoped)
+ */
+const createBorrowingV2Context = (pairIndices, borrowingParams, borrowingData, currentTimestamp) => {
+    const context = {
+        currentTimestamp,
+        borrowingParams: {},
+        borrowingData: {},
+    };
+    // Build objects indexed by pairIndex
+    for (let i = 0; i < pairIndices.length; i++) {
+        const pairIndex = pairIndices[i];
+        // Store converted data
+        context.borrowingParams[pairIndex] = (0, exports.convertBorrowingFeeParams)(borrowingParams[i]);
+        context.borrowingData[pairIndex] = (0, exports.convertPairBorrowingFeeData)(borrowingData[i]);
+    }
+    return context;
+};
+exports.createBorrowingV2Context = createBorrowingV2Context;
+/**
+ * @dev Helper function to validate borrowing rate per second
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns True if rate is within valid bounds
+ */
+const isValidBorrowingRate = (borrowingRatePerSecondP) => {
+    return (borrowingRatePerSecondP >= 0 &&
+        borrowingRatePerSecondP <= 317097 / index_1.BORROWING_V2_PRECISION.RATE_PER_SECOND); // Max 1,000% APR
+};
+exports.isValidBorrowingRate = isValidBorrowingRate;
+/**
+ * @dev Helper function to convert borrowing rate to APR percentage
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns APR as percentage (e.g., 10.5 for 10.5% APR)
+ */
+const borrowingRateToAPR = (borrowingRatePerSecondP) => {
+    const SECONDS_PER_YEAR = 365 * 24 * 60 * 60; // 31,536,000
+    return borrowingRatePerSecondP * SECONDS_PER_YEAR;
+};
+exports.borrowingRateToAPR = borrowingRateToAPR;
+/**
+ * @dev Helper function to convert APR percentage to borrowing rate per second
+ * @param aprPercentage APR as percentage (e.g., 10.5 for 10.5% APR)
+ * @returns Borrowing rate per second (normalized float)
+ */
+const aprToBorrowingRate = (aprPercentage) => {
+    const SECONDS_PER_YEAR = 365 * 24 * 60 * 60; // 31,536,000
+    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/trade/fees/borrowingV2/fetcher.d.ts

@@ -0,0 +1,75 @@
+import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
+import { BorrowingFeeV2 } from ".";
+/**
+ * @dev Fetches borrowing fee parameters v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of borrowing fee parameters
+ */
+export declare const fetchBorrowingFeeParamsV2: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.BorrowingFeeParams[]>;
+/**
+ * @dev Fetches pair borrowing fee data v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of pair borrowing fee data
+ */
+export declare const fetchPairBorrowingFeeDataV2: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.PairBorrowingFeeData[]>;
+/**
+ * @dev Fetches borrowing fees in collateral tokens for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Address of the trader
+ * @param index Trade index
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to borrowing fees in collateral tokens
+ */
+export declare const fetchTradeBorrowingFeesCollateralV2: (contract: GNSMultiCollatDiamond, trader: string, index: number, currentPairPrice: number) => Promise<number>;
+/**
+ * @dev Fetches pending accumulated borrowing fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndex Index of the trading pair
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to pending accumulated borrowing fee
+ */
+export declare const fetchPairPendingAccBorrowingFeesV2: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, currentPairPrice: number) => Promise<number>;
+/**
+ * @dev Convenience function to fetch all borrowing v2 data for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to complete borrowing v2 data set
+ */
+export declare const fetchAllBorrowingV2Data: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndices: number[]) => Promise<{
+    params: BorrowingFeeV2.BorrowingFeeParams[];
+    data: BorrowingFeeV2.PairBorrowingFeeData[];
+    context: BorrowingFeeV2.GetBorrowingFeeV2Context;
+}>;
+/**
+ * @dev Creates a complete borrowing v2 context from contract data
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @param currentTimestamp Optional current timestamp for calculations
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+export declare const createBorrowingV2ContextFromContract: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndices: number[], currentTimestamp?: number) => Promise<BorrowingFeeV2.GetBorrowingFeeV2Context>;
+/**
+ * @dev Helper function to create context from already fetched arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of borrowing fee parameters
+ * @param data Array of pair borrowing fee data
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete borrowing v2 context
+ */
+export declare const createBorrowingV2ContextFromArrays: (collateralIndices: number[], pairIndices: number[], params: BorrowingFeeV2.BorrowingFeeParams[], data: BorrowingFeeV2.PairBorrowingFeeData[], currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;
+/**
+ * @dev Fetches borrowing v2 data for multiple collateral/pair combinations
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices (must match collateralIndices length)
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+export declare const fetchBorrowingV2DataForPairs: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.GetBorrowingFeeV2Context>;

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

@@ -0,0 +1,185 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBorrowingV2DataForPairs = exports.createBorrowingV2ContextFromArrays = exports.createBorrowingV2ContextFromContract = exports.fetchAllBorrowingV2Data = exports.fetchPairPendingAccBorrowingFeesV2 = exports.fetchTradeBorrowingFeesCollateralV2 = exports.fetchPairBorrowingFeeDataV2 = exports.fetchBorrowingFeeParamsV2 = void 0;
+const converter_1 = require("./converter");
+/**
+ * @dev Fetches borrowing fee parameters v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of borrowing fee parameters
+ */
+const fetchBorrowingFeeParamsV2 = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("Collateral indices and pair indices arrays must have the same length");
+    }
+    try {
+        const contractParams = yield contract.getPairBorrowingFeeParams(collateralIndices, pairIndices);
+        return (0, converter_1.convertBorrowingFeeParamsArray)(contractParams);
+    }
+    catch (error) {
+        console.error("Error fetching borrowing fee params v2:", error);
+        throw error;
+    }
+});
+exports.fetchBorrowingFeeParamsV2 = fetchBorrowingFeeParamsV2;
+/**
+ * @dev Fetches pair borrowing fee data v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of pair borrowing fee data
+ */
+const fetchPairBorrowingFeeDataV2 = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("Collateral indices and pair indices arrays must have the same length");
+    }
+    try {
+        const contractData = yield contract.getPairBorrowingFeeData(collateralIndices, pairIndices);
+        return (0, converter_1.convertPairBorrowingFeeDataArray)(contractData);
+    }
+    catch (error) {
+        console.error("Error fetching pair borrowing fee data v2:", error);
+        throw error;
+    }
+});
+exports.fetchPairBorrowingFeeDataV2 = fetchPairBorrowingFeeDataV2;
+/**
+ * @dev Fetches borrowing fees in collateral tokens for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Address of the trader
+ * @param index Trade index
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to borrowing fees in collateral tokens
+ */
+const fetchTradeBorrowingFeesCollateralV2 = (contract, trader, index, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const feesCollateral = yield contract.getTradeBorrowingFeesCollateral(trader, index, currentPairPrice);
+        // Convert BigNumber to normalized float
+        // Note: Collateral precision varies by chain, but contract returns proper precision
+        return parseFloat(feesCollateral.toString());
+    }
+    catch (error) {
+        console.error("Error fetching trade borrowing fees collateral v2:", error);
+        throw error;
+    }
+});
+exports.fetchTradeBorrowingFeesCollateralV2 = fetchTradeBorrowingFeesCollateralV2;
+/**
+ * @dev Fetches pending accumulated borrowing fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndex Index of the trading pair
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to pending accumulated borrowing fee
+ */
+const fetchPairPendingAccBorrowingFeesV2 = (contract, collateralIndex, pairIndex, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const accBorrowingFeeP = yield contract.getPairPendingAccBorrowingFees(collateralIndex, pairIndex, currentPairPrice);
+        // Convert BigNumber to normalized float
+        return parseFloat(accBorrowingFeeP.toString()) / 1e20;
+    }
+    catch (error) {
+        console.error("Error fetching pair pending acc borrowing fees v2:", error);
+        throw error;
+    }
+});
+exports.fetchPairPendingAccBorrowingFeesV2 = fetchPairPendingAccBorrowingFeesV2;
+/**
+ * @dev Convenience function to fetch all borrowing v2 data for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to complete borrowing v2 data set
+ */
+const fetchAllBorrowingV2Data = (contract, collateralIndex, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    const collateralIndices = new Array(pairIndices.length).fill(collateralIndex);
+    try {
+        // Fetch both parameters and data in parallel
+        const [params, data] = yield Promise.all([
+            (0, exports.fetchBorrowingFeeParamsV2)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairBorrowingFeeDataV2)(contract, collateralIndices, pairIndices),
+        ]);
+        // Create context from fetched data
+        const context = (0, exports.createBorrowingV2ContextFromArrays)(collateralIndices, pairIndices, params, data);
+        return { params, data, context };
+    }
+    catch (error) {
+        console.error("Error fetching all borrowing v2 data:", error);
+        throw error;
+    }
+});
+exports.fetchAllBorrowingV2Data = fetchAllBorrowingV2Data;
+/**
+ * @dev Creates a complete borrowing v2 context from contract data
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @param currentTimestamp Optional current timestamp for calculations
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+const createBorrowingV2ContextFromContract = (contract, collateralIndex, pairIndices, currentTimestamp) => __awaiter(void 0, void 0, void 0, function* () {
+    const { context } = yield (0, exports.fetchAllBorrowingV2Data)(contract, collateralIndex, pairIndices);
+    return Object.assign(Object.assign({}, context), { currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000) });
+});
+exports.createBorrowingV2ContextFromContract = createBorrowingV2ContextFromContract;
+/**
+ * @dev Helper function to create context from already fetched arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of borrowing fee parameters
+ * @param data Array of pair borrowing fee data
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete borrowing v2 context
+ */
+const createBorrowingV2ContextFromArrays = (collateralIndices, pairIndices, params, data, currentTimestamp) => {
+    const context = {
+        currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000),
+        borrowingParams: {},
+        borrowingData: {},
+    };
+    // Build objects indexed by pairIndex (collateral-scoped)
+    for (let i = 0; i < pairIndices.length; i++) {
+        const pairIndex = pairIndices[i];
+        // Store data indexed by pairIndex
+        context.borrowingParams[pairIndex] = params[i];
+        context.borrowingData[pairIndex] = data[i];
+    }
+    return context;
+};
+exports.createBorrowingV2ContextFromArrays = createBorrowingV2ContextFromArrays;
+/**
+ * @dev Fetches borrowing v2 data for multiple collateral/pair combinations
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices (must match collateralIndices length)
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+const fetchBorrowingV2DataForPairs = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("Collateral indices and pair indices arrays must have the same length");
+    }
+    try {
+        // Fetch both parameters and data in parallel
+        const [params, data] = yield Promise.all([
+            (0, exports.fetchBorrowingFeeParamsV2)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairBorrowingFeeDataV2)(contract, collateralIndices, pairIndices),
+        ]);
+        // Create and return context
+        return (0, exports.createBorrowingV2ContextFromArrays)(collateralIndices, pairIndices, params, data);
+    }
+    catch (error) {
+        console.error("Error fetching borrowing v2 data for pairs:", error);
+        throw error;
+    }
+});
+exports.fetchBorrowingV2DataForPairs = fetchBorrowingV2DataForPairs;