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

package/lib/contracts/utils/openTrades.js

@@ -14,7 +14,7 @@ const ethcall_1 = require("ethcall");
 const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
     const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
     const collateralPrecisions = (yield contracts.gnsMultiCollatDiamond.getCollaterals()).map(({ precision }) => precision);
-    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
+    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, rawTrade.tradeFeesData, rawTrade.uiRealizedPnlData, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
 });
 exports.fetchOpenPairTrades = fetchOpenPairTrades;
 // @todo rename
@@ -22,7 +22,7 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     if (!contracts) {
         return [];
     }
-    const { batchSize = 50, includeLimits = true, useMulticall = false, } = overrides;
+    const { batchSize = 50, includeLimits = true, useMulticall = false, includeUIRealizedPnlData = true, } = overrides;
     const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
     try {
         const multicallCtx = {
@@ -38,25 +38,52 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
         let running = true;
         let offset = 0;
         while (running) {
-            const trades = yield multiCollatDiamondContract.getAllTrades(offset, offset + batchSize);
-            const tradeInfos = yield multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize);
-            const tradeLiquidationParams = yield multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize);
+            const [trades, tradeInfos, tradeLiquidationParams] = yield Promise.all([
+                multiCollatDiamondContract.getAllTrades(offset, offset + batchSize),
+                multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize),
+                multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize),
+            ]);
+            const fundingFeesCallParams = [
+                [],
+                [], // indices
+            ];
             // Array is always of length `batchSize`
             // so we need to filter out the empty trades, indexes are reliable
             const openTrades = trades
                 .filter(t => t.collateralIndex > 0 &&
                 (includeLimits || (!includeLimits && t.tradeType === 0)))
-                .map((trade, ix) => ({
-                trade,
-                tradeInfo: tradeInfos[ix],
-                liquidationParams: tradeLiquidationParams[ix],
-                initialAccFees: {
-                    accPairFee: 0,
-                    accGroupFee: 0,
-                    block: 0,
-                    __placeholder: 0,
-                },
-            }));
+                .map((trade, ix) => {
+                fundingFeesCallParams[0].push(trade.user);
+                fundingFeesCallParams[1].push(trade.index);
+                return {
+                    trade,
+                    tradeInfo: tradeInfos[ix],
+                    liquidationParams: tradeLiquidationParams[ix],
+                    initialAccFees: {
+                        accPairFee: 0,
+                        accGroupFee: 0,
+                        block: 0,
+                        __placeholder: 0,
+                    },
+                    tradeFeesData: {
+                        realizedTradingFeesCollateral: 0,
+                        realizedPnlCollateral: 0,
+                        manuallyRealizedNegativePnlCollateral: 0,
+                        alreadyTransferredNegativePnlCollateral: 0,
+                        virtualAvailableCollateralInDiamond: 0,
+                        initialAccFundingFeeP: 0,
+                        initialAccBorrowingFeeP: 0,
+                        __placeholder: 0,
+                    },
+                    uiRealizedPnlData: undefined,
+                };
+            });
+            const [tradeFeesData, uiRealizedPnlData] = yield Promise.all([
+                multiCollatDiamondContract.getTradeFeesDataArray(...fundingFeesCallParams),
+                includeUIRealizedPnlData
+                    ? multiCollatDiamondContract.getTradeUiRealizedPnlDataArray(...fundingFeesCallParams)
+                    : [],
+            ]);
             const initialAccFeesPromises = openTrades
                 .map(({ trade }) => ({
                 collateralIndex: trade.collateralIndex,
@@ -71,6 +98,8 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                 : Promise.all(initialAccFeesPromises));
             initialAccFees.forEach((accFees, ix) => {
                 openTrades[ix].initialAccFees = accFees;
+                openTrades[ix].tradeFeesData = tradeFeesData[ix];
+                openTrades[ix].uiRealizedPnlData = uiRealizedPnlData === null || uiRealizedPnlData === void 0 ? void 0 : uiRealizedPnlData[ix];
             });
             allOpenPairTrades = allOpenPairTrades.concat(openTrades);
             offset += batchSize + 1;
@@ -85,42 +114,67 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     }
 });
 exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
-const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, collateralPrecision) => ({
-    trade: {
-        user: trade.user,
-        index: parseInt(trade.index.toString()),
-        pairIndex: parseInt(trade.pairIndex.toString()),
-        leverage: parseFloat(trade.leverage.toString()) / 1e3,
-        long: trade.long.toString() === "true",
-        isOpen: trade.isOpen.toString() === "true",
-        collateralIndex: parseInt(trade.collateralIndex.toString()),
-        tradeType: trade.tradeType,
-        collateralAmount: parseFloat(trade.collateralAmount.toString()) /
-            parseFloat(collateralPrecision.toString()),
-        openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
-        tp: parseFloat(trade.tp.toString()) / 1e10,
-        sl: parseFloat(trade.sl.toString()) / 1e10,
-    },
-    tradeInfo: {
-        createdBlock: parseInt(tradeInfo.createdBlock.toString()),
-        tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
-        slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
-        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
-        lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
-        collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
-        contractsVersion: parseInt(tradeInfo.contractsVersion.toString()),
-        lastPosIncreaseBlock: parseInt(tradeInfo.lastPosIncreaseBlock.toString()),
-    },
-    liquidationParams: {
-        maxLiqSpreadP: parseFloat(tradeLiquidationParams.maxLiqSpreadP.toString()) / 1e12,
-        startLiqThresholdP: parseFloat(tradeLiquidationParams.startLiqThresholdP.toString()) / 1e12,
-        endLiqThresholdP: parseFloat(tradeLiquidationParams.endLiqThresholdP.toString()) / 1e12,
-        startLeverage: parseFloat(tradeLiquidationParams.startLeverage.toString()) / 1e3,
-        endLeverage: parseFloat(tradeLiquidationParams.endLeverage.toString()) / 1e3,
-    },
-    initialAccFees: {
-        accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
-        accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
-        block: parseFloat(tradeInitialAccFees.block.toString()),
-    },
-});
+const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, tradeFeesData, uiRealizedPnlData, collateralPrecision) => {
+    const precision = parseFloat(collateralPrecision.toString());
+    return {
+        trade: {
+            user: trade.user,
+            index: parseInt(trade.index.toString()),
+            pairIndex: parseInt(trade.pairIndex.toString()),
+            leverage: parseFloat(trade.leverage.toString()) / 1e3,
+            long: trade.long.toString() === "true",
+            isOpen: trade.isOpen.toString() === "true",
+            collateralIndex: parseInt(trade.collateralIndex.toString()),
+            tradeType: trade.tradeType,
+            collateralAmount: parseFloat(trade.collateralAmount.toString()) / precision,
+            openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
+            tp: parseFloat(trade.tp.toString()) / 1e10,
+            sl: parseFloat(trade.sl.toString()) / 1e10,
+            isCounterTrade: trade.isCounterTrade,
+            positionSizeToken: parseFloat(trade.positionSizeToken.toString()) / 1e18,
+        },
+        tradeInfo: {
+            createdBlock: parseInt(tradeInfo.createdBlock.toString()),
+            tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
+            slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
+            maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
+            lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
+            collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
+            contractsVersion: parseInt(tradeInfo.contractsVersion.toString()),
+            lastPosIncreaseBlock: parseInt(tradeInfo.lastPosIncreaseBlock.toString()),
+        },
+        liquidationParams: {
+            maxLiqSpreadP: parseFloat(tradeLiquidationParams.maxLiqSpreadP.toString()) / 1e12,
+            startLiqThresholdP: parseFloat(tradeLiquidationParams.startLiqThresholdP.toString()) / 1e12,
+            endLiqThresholdP: parseFloat(tradeLiquidationParams.endLiqThresholdP.toString()) / 1e12,
+            startLeverage: parseFloat(tradeLiquidationParams.startLeverage.toString()) / 1e3,
+            endLeverage: parseFloat(tradeLiquidationParams.endLeverage.toString()) / 1e3,
+        },
+        initialAccFees: {
+            accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
+            accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
+            block: parseFloat(tradeInitialAccFees.block.toString()),
+        },
+        tradeFeesData: {
+            realizedTradingFeesCollateral: parseFloat(tradeFeesData.realizedTradingFeesCollateral.toString()) /
+                precision,
+            realizedPnlCollateral: parseFloat(tradeFeesData.realizedPnlCollateral.toString()) / precision,
+            manuallyRealizedNegativePnlCollateral: parseFloat(tradeFeesData.manuallyRealizedNegativePnlCollateral.toString()) / precision,
+            alreadyTransferredNegativePnlCollateral: parseFloat(tradeFeesData.alreadyTransferredNegativePnlCollateral.toString()) / precision,
+            virtualAvailableCollateralInDiamond: parseFloat(tradeFeesData.virtualAvailableCollateralInDiamond.toString()) / precision,
+            initialAccFundingFeeP: parseFloat(tradeFeesData.initialAccFundingFeeP.toString()) / 1e10,
+            initialAccBorrowingFeeP: parseFloat(tradeFeesData.initialAccBorrowingFeeP.toString()) / 1e10,
+        },
+        uiRealizedPnlData: uiRealizedPnlData
+            ? {
+                realizedTradingFeesCollateral: parseFloat(uiRealizedPnlData.realizedTradingFeesCollateral.toString()) / precision,
+                realizedOldBorrowingFeesCollateral: parseFloat(uiRealizedPnlData.realizedOldBorrowingFeesCollateral.toString()) / precision,
+                realizedNewBorrowingFeesCollateral: parseFloat(uiRealizedPnlData.realizedNewBorrowingFeesCollateral.toString()) / precision,
+                realizedFundingFeesCollateral: parseFloat(uiRealizedPnlData.realizedFundingFeesCollateral.toString()) / precision,
+                realizedPnlPartialCloseCollateral: parseFloat(uiRealizedPnlData.realizedPnlPartialCloseCollateral.toString()) / precision,
+                pnlWithdrawnCollateral: parseFloat(uiRealizedPnlData.pnlWithdrawnCollateral.toString()) /
+                    precision,
+            }
+            : undefined,
+    };
+};

package/lib/contracts/utils/pairs.js

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

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

@@ -5,6 +5,16 @@ export type GetBorrowingFeeContext = {
     groups: BorrowingFee.Group[];
     pairs: BorrowingFee.Pair[];
 };
+/**
+ * @dev Calculates borrowing fees using v1 model (block-based with groups)
+ * @dev Still actively used by markets that haven't migrated to v2
+ * @param posDai Position size in collateral
+ * @param pairIndex Trading pair index
+ * @param long Whether position is long
+ * @param initialAccFees Initial accumulated fees when trade was opened
+ * @param context Context with current block and fee data
+ * @returns Borrowing fee in collateral tokens
+ */
 export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;
 export declare const withinMaxGroupOi: (pairIndex: PairIndex, long: boolean, positionSizeCollateral: number, context: {
     groups: BorrowingFee.Group[];

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

@@ -27,6 +27,16 @@ 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
+ * @param posDai Position size in collateral
+ * @param pairIndex Trading pair index
+ * @param long Whether position is long
+ * @param initialAccFees Initial accumulated fees when trade was opened
+ * @param context Context with current block and fee data
+ * @returns Borrowing fee in collateral tokens
+ */
 const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
     if (!context.groups || !context.pairs || !context.pairs[pairIndex]) {
         return 0;

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

@@ -0,0 +1,66 @@
+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 collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param borrowingParams Array of borrowing fee params from contract
+ * @param borrowingData Array of pair borrowing fee data from contract
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete SDK context for borrowing v2 calculations
+ */
+export declare const createBorrowingV2Context: (collateralIndices: number[], 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;

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aprToBorrowingRate = exports.borrowingRateToAPR = exports.isValidBorrowingRate = exports.createBorrowingV2Context = exports.convertTradeInitialAccFeesArray = exports.convertTradeInitialAccFees = exports.convertPairBorrowingFeeDataArray = exports.convertPairBorrowingFeeData = exports.convertBorrowingFeeParamsArray = exports.convertBorrowingFeeParams = void 0;
+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 collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param borrowingParams Array of borrowing fee params from contract
+ * @param borrowingData Array of pair borrowing fee data from contract
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete SDK context for borrowing v2 calculations
+ */
+const createBorrowingV2Context = (collateralIndices, pairIndices, borrowingParams, borrowingData, currentTimestamp) => {
+    const context = {
+        currentTimestamp,
+        borrowingParams: {},
+        borrowingData: {},
+    };
+    // Build nested objects indexed by collateralIndex and pairIndex
+    for (let i = 0; i < collateralIndices.length; i++) {
+        const collateralIndex = collateralIndices[i];
+        const pairIndex = pairIndices[i];
+        // Initialize collateral index objects if they don't exist
+        if (!context.borrowingParams[collateralIndex]) {
+            context.borrowingParams[collateralIndex] = {};
+        }
+        if (!context.borrowingData[collateralIndex]) {
+            context.borrowingData[collateralIndex] = {};
+        }
+        // Store converted data
+        context.borrowingParams[collateralIndex][pairIndex] =
+            (0, exports.convertBorrowingFeeParams)(borrowingParams[i]);
+        context.borrowingData[collateralIndex][pairIndex] =
+            (0, exports.convertPairBorrowingFeeData)(borrowingData[i]);
+    }
+    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;

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

@@ -0,0 +1,59 @@
+import * as BorrowingFeeV2 from "./types";
+/**
+ * @dev Maximum borrowing rate per second (1,000% APR)
+ */
+export declare const MAX_BORROWING_RATE_PER_SECOND = 0.0317097;
+/**
+ * @dev Precision constants for borrowing v2 calculations
+ */
+export declare const BORROWING_V2_PRECISION: {
+    readonly RATE_PER_SECOND: 10000000000;
+    readonly ACC_FEE: 100000000000000000000;
+    readonly PERCENTAGE: 100;
+};
+/**
+ * @dev Calculates pending accumulated borrowing fees for a pair
+ * @param params Borrowing fee parameters for the pair
+ * @param data Current borrowing fee data for the pair
+ * @param currentPairPrice Current price of the trading pair
+ * @param currentTimestamp Current timestamp (defaults to now)
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+export declare const getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
+/**
+ * @dev Calculates borrowing fees owed by a specific trade
+ * @param input Trade borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+export declare const getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @dev Convenience function to calculate borrowing fees for a trade using individual parameters
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param pairIndex Index of the trading pair
+ * @param collateralIndex Index of the collateral
+ * @param openPrice Price at which the trade was opened
+ * @param currentPairPrice Current price of the trading pair
+ * @param initialAccBorrowingFeeP Initial accumulated borrowing fee when trade was opened
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+export declare const getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @dev Utility function to get pending accumulated borrowing fees for a pair using context
+ * @param input Pair borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+export declare const getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @dev Utility functions for working with borrowing v2 fees
+ */
+export declare const borrowingFeeV2Utils: {
+    getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
+    getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+    getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+    getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+};
+export * as BorrowingFeeV2 from "./types";
+export * from "./converter";

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

@@ -0,0 +1,139 @@
+"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.BorrowingFeeV2 = exports.borrowingFeeV2Utils = exports.getPairBorrowingFees = exports.getBorrowingFee = exports.getTradeBorrowingFeesCollateral = exports.getPairPendingAccBorrowingFees = exports.BORROWING_V2_PRECISION = exports.MAX_BORROWING_RATE_PER_SECOND = void 0;
+/**
+ * @dev Maximum borrowing rate per second (1,000% APR)
+ */
+exports.MAX_BORROWING_RATE_PER_SECOND = 0.0317097; // 317097 / 1e10
+/**
+ * @dev Precision constants for borrowing v2 calculations
+ */
+exports.BORROWING_V2_PRECISION = {
+    RATE_PER_SECOND: 1e10,
+    ACC_FEE: 1e20,
+    PERCENTAGE: 100,
+};
+/**
+ * @dev Calculates pending accumulated borrowing fees for a pair
+ * @param params Borrowing fee parameters for the pair
+ * @param data Current borrowing fee data for the pair
+ * @param currentPairPrice Current price of the trading pair
+ * @param currentTimestamp Current timestamp (defaults to now)
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+const getPairPendingAccBorrowingFees = (params, data, currentPairPrice, currentTimestamp) => {
+    const timestamp = currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000);
+    // Calculate time elapsed since last update
+    const timeElapsed = Math.max(0, timestamp - data.lastBorrowingUpdateTs);
+    // If no time elapsed, return current accumulated fee
+    if (timeElapsed === 0) {
+        return data.accBorrowingFeeP;
+    }
+    // Calculate accumulated borrowing fee delta
+    // Formula: borrowingRatePerSecondP * timeElapsed * currentPairPrice
+    const accBorrowingFeeDeltaP = params.borrowingRatePerSecondP * timeElapsed * currentPairPrice;
+    return data.accBorrowingFeeP + accBorrowingFeeDeltaP;
+};
+exports.getPairPendingAccBorrowingFees = getPairPendingAccBorrowingFees;
+/**
+ * @dev Calculates borrowing fees owed by a specific trade
+ * @param input Trade borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+const getTradeBorrowingFeesCollateral = (input, context) => {
+    var _a, _b;
+    const { positionSizeCollateral, openPrice, collateralIndex, pairIndex, currentPairPrice, initialAccBorrowingFeeP, currentTimestamp, } = input;
+    // Get borrowing parameters and data for the pair
+    const params = (_a = context.borrowingParams[collateralIndex]) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const data = (_b = context.borrowingData[collateralIndex]) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    if (!params || !data) {
+        return 0;
+    }
+    // Calculate current accumulated borrowing fees
+    const currentAccBorrowingFeeP = (0, exports.getPairPendingAccBorrowingFees)(params, data, currentPairPrice, currentTimestamp);
+    // Calculate borrowing fees for this trade
+    // Formula: (positionSizeCollateral * (currentAccFee - initialAccFee)) / openPrice / 100
+    const feeDeltaP = currentAccBorrowingFeeP - initialAccBorrowingFeeP;
+    return ((positionSizeCollateral * feeDeltaP) /
+        openPrice /
+        exports.BORROWING_V2_PRECISION.PERCENTAGE);
+};
+exports.getTradeBorrowingFeesCollateral = getTradeBorrowingFeesCollateral;
+/**
+ * @dev Convenience function to calculate borrowing fees for a trade using individual parameters
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param pairIndex Index of the trading pair
+ * @param collateralIndex Index of the collateral
+ * @param openPrice Price at which the trade was opened
+ * @param currentPairPrice Current price of the trading pair
+ * @param initialAccBorrowingFeeP Initial accumulated borrowing fee when trade was opened
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+const getBorrowingFee = (positionSizeCollateral, pairIndex, collateralIndex, openPrice, currentPairPrice, initialAccBorrowingFeeP, context) => {
+    return (0, exports.getTradeBorrowingFeesCollateral)({
+        positionSizeCollateral,
+        openPrice,
+        collateralIndex,
+        pairIndex,
+        currentPairPrice,
+        initialAccBorrowingFeeP,
+        currentTimestamp: context.currentTimestamp,
+    }, context);
+};
+exports.getBorrowingFee = getBorrowingFee;
+/**
+ * @dev Utility function to get pending accumulated borrowing fees for a pair using context
+ * @param input Pair borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+const getPairBorrowingFees = (input, context) => {
+    var _a, _b;
+    const { collateralIndex, pairIndex, currentPairPrice, currentTimestamp } = input;
+    const params = (_a = context.borrowingParams[collateralIndex]) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const data = (_b = context.borrowingData[collateralIndex]) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    if (!params || !data) {
+        return 0;
+    }
+    return (0, exports.getPairPendingAccBorrowingFees)(params, data, currentPairPrice, currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : context.currentTimestamp);
+};
+exports.getPairBorrowingFees = getPairBorrowingFees;
+/**
+ * @dev Utility functions for working with borrowing v2 fees
+ */
+exports.borrowingFeeV2Utils = {
+    getPairPendingAccBorrowingFees: exports.getPairPendingAccBorrowingFees,
+    getTradeBorrowingFeesCollateral: exports.getTradeBorrowingFeesCollateral,
+    getPairBorrowingFees: exports.getPairBorrowingFees,
+    getBorrowingFee: exports.getBorrowingFee,
+};
+exports.BorrowingFeeV2 = __importStar(require("./types"));
+__exportStar(require("./converter"), exports);