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

package/lib/markets/price/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @dev Market price module exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./marketPrice"), exports);
+__exportStar(require("./builder"), exports);

package/lib/markets/price/marketPrice.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @dev Current market price calculation with skew impact
+ */
+import { MarketPriceResult, MarketPriceContext } from "./types";
+/**
+ * @dev Calculates the current market price adjusted for skew impact
+ * @param pairIndex Trading pair index
+ * @param oraclePrice Oracle price for the pair
+ * @param context Market price context with depths and OI data
+ * @returns Current market price with skew impact applied
+ */
+export declare const getCurrentMarketPrice: (pairIndex: number, oraclePrice: number, context: MarketPriceContext) => MarketPriceResult;

package/lib/markets/price/marketPrice.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * @dev Current market price calculation with skew impact
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentMarketPrice = void 0;
+const skew_1 = require("../../trade/priceImpact/skew");
+/**
+ * @dev Calculates the current market price adjusted for skew impact
+ * @param pairIndex Trading pair index
+ * @param oraclePrice Oracle price for the pair
+ * @param context Market price context with depths and OI data
+ * @returns Current market price with skew impact applied
+ */
+const getCurrentMarketPrice = (pairIndex, oraclePrice, context) => {
+    let skewImpactP = 0;
+    if (context.skewDepth > 0) {
+        const skewResult = (0, skew_1.getTradeSkewPriceImpact)({
+            collateralIndex: 0,
+            pairIndex,
+            long: true,
+            open: true,
+            positionSizeToken: 0, // Size 0 for current market price
+        }, context);
+        skewImpactP = skewResult.priceImpactP;
+    }
+    const marketPrice = oraclePrice * (1 + skewImpactP / 100);
+    return {
+        marketPrice,
+        skewImpactP,
+        oraclePrice,
+    };
+};
+exports.getCurrentMarketPrice = getCurrentMarketPrice;

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

@@ -0,0 +1,23 @@
+/**
+ * @dev Market price types for calculating price with skew impact
+ */
+export type MarketPriceInput = {
+    collateralIndex: number;
+    pairIndex: number;
+    oraclePrice: number;
+    long: boolean;
+    open: boolean;
+    positionSizeCollateral: number;
+};
+export type MarketPriceResult = {
+    marketPrice: number;
+    skewImpactP: number;
+    oraclePrice: number;
+};
+export type MarketPriceContext = {
+    skewDepth: number;
+    pairOiToken: {
+        oiLongToken: number;
+        oiShortToken: number;
+    };
+};

package/lib/markets/price/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Market price types for calculating price with skew impact
+ */
+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,8 +4,25 @@ export type GetBorrowingFeeContext = {
     currentBlock: number;
     groups: BorrowingFee.Group[];
     pairs: BorrowingFee.Pair[];
+    collateralPriceUsd: number;
 };
-export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => 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 (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, context: GetBorrowingFeeContext) => number;
+/**
+ * @deprecated Use withinMaxGroupOiDynamic from @gains-network/sdk/markets/oi instead
+ * @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[];
@@ -19,6 +36,7 @@ export declare const borrowingFeeUtils: {
     getPairPendingAccFees: (pairIndex: PairIndex, currentBlock: number, context: {
         pairs: BorrowingFee.Pair[];
         openInterest: OpenInterest;
+        collateralPriceUsd: number;
     }) => {
         accFeeLong: number;
         accFeeShort: number;
@@ -28,9 +46,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;
@@ -39,8 +59,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;
@@ -56,3 +77,4 @@ export declare const borrowingFeeUtils: {
 };
 export * as BorrowingFee from "./types";
 export * from "./converter";
+export * from "./builder";

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,11 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
     return (posDai * fee) / 100;
 };
 exports.getBorrowingFee = getBorrowingFee;
+/**
+ * @deprecated Use withinMaxGroupOiDynamic from @gains-network/sdk/markets/oi instead
+ * @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 +100,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 +123,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 +155,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 +168,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 +241,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;