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

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

@@ -30,11 +30,12 @@ exports.BorrowingFee = exports.borrowingFeeUtils = exports.withinMaxGroupOi = ex
 /**
  * @dev Calculates borrowing fees using v1 model (block-based with groups)
  * @dev Still actively used by markets that haven't migrated to v2
+ * @dev Uses dynamic collateral OI - converts OI to USD for fee calculations
  * @param posDai Position size in collateral
  * @param pairIndex Trading pair index
  * @param long Whether position is long
  * @param initialAccFees Initial accumulated fees when trade was opened
- * @param context Context with current block and fee data
+ * @param context Context with current block, fee data, and collateral price
  * @returns Borrowing fee in collateral tokens
  */
 const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
@@ -52,6 +53,7 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
                 ? getPairPendingAccFee(pairIndex, context.currentBlock, long, {
                     pairs,
                     openInterest,
+                    collateralPriceUsd: context.collateralPriceUsd,
                 })
                 : long
                     ? firstPairGroup.pairAccFeeLong
@@ -67,6 +69,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) {
@@ -85,18 +92,19 @@ const getPairGroupIndex = (pairIndex, context) => {
     return pairGroups.length == 0 ? 0 : pairGroups[0].groupIndex;
 };
 const getPairPendingAccFees = (pairIndex, currentBlock, context) => {
-    const { pairs, openInterest: { long, short }, } = context;
+    const { pairs, openInterest: { long, short }, collateralPriceUsd, } = context;
     const pair = pairs[pairIndex];
-    return getPendingAccFees(pair.accFeeLong, pair.accFeeShort, long, short, pair.feePerBlock, currentBlock, pair.accLastUpdatedBlock, pair.oi.max, pair.feeExponent, pair.feePerBlockCap);
+    return getPendingAccFees(pair.accFeeLong, pair.accFeeShort, long, short, pair.feePerBlock, currentBlock, pair.accLastUpdatedBlock, pair.oi.max, pair.feeExponent, pair.feePerBlockCap, collateralPriceUsd);
 };
 const getPairPendingAccFee = (pairIndex, currentBlock, long, context) => {
     const { accFeeLong, accFeeShort } = getPairPendingAccFees(pairIndex, currentBlock, context);
     return long ? accFeeLong : accFeeShort;
 };
 const getGroupPendingAccFees = (groupIndex, currentBlock, context) => {
-    const { groups } = context;
+    const { groups, collateralPriceUsd } = context;
     const group = groups[groupIndex];
-    return getPendingAccFees(group.accFeeLong, group.accFeeShort, group.oi.long, group.oi.short, group.feePerBlock, currentBlock, group.accLastUpdatedBlock, group.oi.max, group.feeExponent);
+    return getPendingAccFees(group.accFeeLong, group.accFeeShort, group.oi.long, group.oi.short, group.feePerBlock, currentBlock, group.accLastUpdatedBlock, group.oi.max, group.feeExponent, undefined, // no fee caps for groups
+    collateralPriceUsd);
 };
 const getGroupPendingAccFee = (groupIndex, currentBlock, long, context) => {
     const { accFeeLong, accFeeShort } = getGroupPendingAccFees(groupIndex, currentBlock, context);
@@ -107,14 +115,16 @@ const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long,
     const beforeTradeOpen = group.block < initialFees.block;
     let deltaGroup, deltaPair;
     if (i == pairGroups.length - 1) {
-        const { currentBlock, groups, pairs } = context;
+        const { currentBlock, groups, pairs, collateralPriceUsd } = context;
         const openInterest = pairs[pairIndex].oi;
         deltaGroup = getGroupPendingAccFee(group.groupIndex, currentBlock, long, {
             groups,
+            collateralPriceUsd,
         });
         deltaPair = getPairPendingAccFee(pairIndex, currentBlock, long, {
             pairs,
             openInterest,
+            collateralPriceUsd,
         });
     }
     else {
@@ -137,8 +147,8 @@ const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long,
     }
     return { deltaGroup, deltaPair, beforeTradeOpen };
 };
-const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock, currentBlock, accLastUpdatedBlock, maxOi, feeExponent, feeCaps // as percentage: eg minP: 0.1 = 10%, maxP: 0.5 = 50%
-) => {
+const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock, currentBlock, accLastUpdatedBlock, maxOi, feeExponent, feeCaps, // as percentage: eg minP: 0.1 = 10%, maxP: 0.5 = 50%
+collateralPriceUsd) => {
     const moreShorts = oiLong < oiShort;
     const blockDistance = currentBlock > accLastUpdatedBlock ? currentBlock - accLastUpdatedBlock : 0;
     // If block distance is zero nothing changes
@@ -150,19 +160,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]

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,193 @@
+"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 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 data
+        context.borrowingParams[collateralIndex][pairIndex] = params[i];
+        context.borrowingData[collateralIndex][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;

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

@@ -57,3 +57,4 @@ export declare const borrowingFeeV2Utils: {
 };
 export * as BorrowingFeeV2 from "./types";
 export * from "./converter";
+export * from "./fetcher";

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

@@ -137,3 +137,4 @@ exports.borrowingFeeV2Utils = {
 };
 exports.BorrowingFeeV2 = __importStar(require("./types"));
 __exportStar(require("./converter"), exports);
+__exportStar(require("./fetcher"), exports);

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

@@ -0,0 +1,48 @@
+/**
+ * @dev Converters for fee data between contract and SDK formats
+ */
+import { IFundingFees } from "../../contracts/types/generated/GNSMultiCollatDiamond";
+import { TradeFeesData, UiRealizedPnlData } from "../types";
+import { CollateralConfig } from "../../markets/collateral/types";
+/**
+ * @dev Converts contract TradeFeesData to SDK format
+ * @param data Trade fees data from contract
+ * @param collateralConfig Config for the collateral (contains decimals)
+ * @returns Normalized trade fees data
+ */
+export declare const convertTradeFeesData: (data: IFundingFees.TradeFeesDataStructOutput, collateralConfig: CollateralConfig) => TradeFeesData;
+/**
+ * @dev Converts array of TradeFeesData from contract
+ * @param dataArray Array of trade fees data
+ * @param collateralConfig Config for the collateral
+ * @returns Array of normalized trade fees data
+ */
+export declare const convertTradeFeesDataArray: (dataArray: IFundingFees.TradeFeesDataStructOutput[], collateralConfig: CollateralConfig) => TradeFeesData[];
+/**
+ * @dev Converts contract UiRealizedPnlData to SDK format
+ * @param data UI realized PnL data from contract
+ * @param collateralConfig Config for the collateral (contains decimals)
+ * @returns Normalized UI realized PnL data
+ */
+export declare const convertUiRealizedPnlData: (data: IFundingFees.UiRealizedPnlDataStructOutput, collateralConfig: CollateralConfig) => UiRealizedPnlData;
+/**
+ * @dev Converts array of UiRealizedPnlData from contract
+ * @param dataArray Array of UI realized PnL data
+ * @param collateralConfig Config for the collateral
+ * @returns Array of normalized UI realized PnL data
+ */
+export declare const convertUiRealizedPnlDataArray: (dataArray: IFundingFees.UiRealizedPnlDataStructOutput[], collateralConfig: CollateralConfig) => UiRealizedPnlData[];
+/**
+ * @dev Converts TradeFeesData to contract format (for encoding)
+ * @param data SDK trade fees data
+ * @param collateralConfig Config for the collateral
+ * @returns Contract-formatted trade fees data
+ */
+export declare const encodeTradeFeesData: (data: TradeFeesData, collateralConfig: CollateralConfig) => IFundingFees.TradeFeesDataStruct;
+/**
+ * @dev Converts UiRealizedPnlData to contract format (for encoding)
+ * @param data SDK UI realized PnL data
+ * @param collateralConfig Config for the collateral
+ * @returns Contract-formatted UI realized PnL data
+ */
+export declare const encodeUiRealizedPnlData: (data: UiRealizedPnlData, collateralConfig: CollateralConfig) => IFundingFees.UiRealizedPnlDataStruct;

package/lib/trade/fees/converter.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * @dev Converters for fee data between contract and SDK formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeUiRealizedPnlData = exports.encodeTradeFeesData = exports.convertUiRealizedPnlDataArray = exports.convertUiRealizedPnlData = exports.convertTradeFeesDataArray = exports.convertTradeFeesData = void 0;
+/**
+ * @dev Converts contract TradeFeesData to SDK format
+ * @param data Trade fees data from contract
+ * @param collateralConfig Config for the collateral (contains decimals)
+ * @returns Normalized trade fees data
+ */
+const convertTradeFeesData = (data, collateralConfig) => {
+    const decimals = collateralConfig.decimals || 18;
+    return {
+        realizedTradingFeesCollateral: parseFloat(data.realizedTradingFeesCollateral.toString()) /
+            Math.pow(10, decimals),
+        realizedPnlCollateral: parseFloat(data.realizedPnlCollateral.toString()) / Math.pow(10, decimals),
+        manuallyRealizedNegativePnlCollateral: parseFloat(data.manuallyRealizedNegativePnlCollateral.toString()) /
+            Math.pow(10, decimals),
+        alreadyTransferredNegativePnlCollateral: parseFloat(data.alreadyTransferredNegativePnlCollateral.toString()) /
+            Math.pow(10, decimals),
+        virtualAvailableCollateralInDiamond: parseFloat(data.virtualAvailableCollateralInDiamond.toString()) /
+            Math.pow(10, decimals),
+        initialAccFundingFeeP: parseFloat(data.initialAccFundingFeeP.toString()) / 1e10,
+        initialAccBorrowingFeeP: parseFloat(data.initialAccBorrowingFeeP.toString()) / 1e10,
+    };
+};
+exports.convertTradeFeesData = convertTradeFeesData;
+/**
+ * @dev Converts array of TradeFeesData from contract
+ * @param dataArray Array of trade fees data
+ * @param collateralConfig Config for the collateral
+ * @returns Array of normalized trade fees data
+ */
+const convertTradeFeesDataArray = (dataArray, collateralConfig) => {
+    return dataArray.map(data => (0, exports.convertTradeFeesData)(data, collateralConfig));
+};
+exports.convertTradeFeesDataArray = convertTradeFeesDataArray;
+/**
+ * @dev Converts contract UiRealizedPnlData to SDK format
+ * @param data UI realized PnL data from contract
+ * @param collateralConfig Config for the collateral (contains decimals)
+ * @returns Normalized UI realized PnL data
+ */
+const convertUiRealizedPnlData = (data, collateralConfig) => {
+    const decimals = collateralConfig.decimals || 18;
+    return {
+        realizedTradingFeesCollateral: parseFloat(data.realizedTradingFeesCollateral.toString()) /
+            Math.pow(10, decimals),
+        realizedOldBorrowingFeesCollateral: parseFloat(data.realizedOldBorrowingFeesCollateral.toString()) /
+            Math.pow(10, decimals),
+        realizedNewBorrowingFeesCollateral: parseFloat(data.realizedNewBorrowingFeesCollateral.toString()) /
+            Math.pow(10, decimals),
+        realizedFundingFeesCollateral: parseFloat(data.realizedFundingFeesCollateral.toString()) /
+            Math.pow(10, decimals),
+        realizedPnlPartialCloseCollateral: parseFloat(data.realizedPnlPartialCloseCollateral.toString()) /
+            Math.pow(10, decimals),
+        pnlWithdrawnCollateral: parseFloat(data.pnlWithdrawnCollateral.toString()) / Math.pow(10, decimals),
+    };
+};
+exports.convertUiRealizedPnlData = convertUiRealizedPnlData;
+/**
+ * @dev Converts array of UiRealizedPnlData from contract
+ * @param dataArray Array of UI realized PnL data
+ * @param collateralConfig Config for the collateral
+ * @returns Array of normalized UI realized PnL data
+ */
+const convertUiRealizedPnlDataArray = (dataArray, collateralConfig) => {
+    return dataArray.map(data => (0, exports.convertUiRealizedPnlData)(data, collateralConfig));
+};
+exports.convertUiRealizedPnlDataArray = convertUiRealizedPnlDataArray;
+/**
+ * @dev Converts TradeFeesData to contract format (for encoding)
+ * @param data SDK trade fees data
+ * @param collateralConfig Config for the collateral
+ * @returns Contract-formatted trade fees data
+ */
+const encodeTradeFeesData = (data, collateralConfig) => {
+    const decimals = collateralConfig.decimals || 18;
+    return {
+        realizedTradingFeesCollateral: Math.round(data.realizedTradingFeesCollateral * Math.pow(10, decimals)),
+        realizedPnlCollateral: Math.round(data.realizedPnlCollateral * Math.pow(10, decimals)),
+        manuallyRealizedNegativePnlCollateral: Math.round(data.manuallyRealizedNegativePnlCollateral * Math.pow(10, decimals)),
+        alreadyTransferredNegativePnlCollateral: Math.round(data.alreadyTransferredNegativePnlCollateral * Math.pow(10, decimals)),
+        virtualAvailableCollateralInDiamond: Math.round(data.virtualAvailableCollateralInDiamond * Math.pow(10, decimals)),
+        __placeholder: 0,
+        initialAccFundingFeeP: Math.round(data.initialAccFundingFeeP * 1e10),
+        initialAccBorrowingFeeP: Math.round(data.initialAccBorrowingFeeP * 1e10),
+    };
+};
+exports.encodeTradeFeesData = encodeTradeFeesData;
+/**
+ * @dev Converts UiRealizedPnlData to contract format (for encoding)
+ * @param data SDK UI realized PnL data
+ * @param collateralConfig Config for the collateral
+ * @returns Contract-formatted UI realized PnL data
+ */
+const encodeUiRealizedPnlData = (data, collateralConfig) => {
+    const decimals = collateralConfig.decimals || 18;
+    return {
+        realizedTradingFeesCollateral: Math.round(data.realizedTradingFeesCollateral * Math.pow(10, decimals)),
+        realizedOldBorrowingFeesCollateral: Math.round(data.realizedOldBorrowingFeesCollateral * Math.pow(10, decimals)),
+        realizedNewBorrowingFeesCollateral: Math.round(data.realizedNewBorrowingFeesCollateral * Math.pow(10, decimals)),
+        realizedFundingFeesCollateral: Math.round(data.realizedFundingFeesCollateral * Math.pow(10, decimals)),
+        realizedPnlPartialCloseCollateral: Math.round(data.realizedPnlPartialCloseCollateral * Math.pow(10, decimals)),
+        pnlWithdrawnCollateral: Math.round(data.pnlWithdrawnCollateral * Math.pow(10, decimals)),
+    };
+};
+exports.encodeUiRealizedPnlData = encodeUiRealizedPnlData;

package/lib/trade/fees/fundingFees/fetcher.d.ts

@@ -0,0 +1,66 @@
+import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
+import type { TradeInitialAccFees } from ".";
+/**
+ * @dev Fetches pending accumulated funding fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param currentPairPrice Current pair price (1e10)
+ * @returns Promise resolving to accumulated funding fees and current rate
+ */
+export declare const fetchPairPendingAccFundingFees: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, currentPairPrice: bigint) => Promise<{
+    accFundingFeeLongP: number;
+    accFundingFeeShortP: number;
+    currentFundingRatePerSecondP: number;
+}>;
+/**
+ * @dev Fetches funding fees for a specific trade in collateral tokens
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Trader address
+ * @param index Trade index
+ * @param currentPairPrice Current pair price (1e10)
+ * @returns Promise resolving to funding fee in collateral tokens
+ */
+export declare const fetchTradeFundingFeesCollateral: (contract: GNSMultiCollatDiamond, trader: string, index: number, currentPairPrice: bigint) => Promise<number>;
+/**
+ * @dev Fetches trade fees data for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Trader address
+ * @param index Trade index
+ * @returns Promise resolving to trade fees data
+ */
+export declare const fetchTradeFeesData: (contract: GNSMultiCollatDiamond, trader: string, index: number) => Promise<TradeInitialAccFees>;
+/**
+ * @dev Fetches trade fees data for multiple trades
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param traders Array of trader addresses
+ * @param indices Array of trade indices
+ * @returns Promise resolving to array of trade fees data
+ */
+export declare const fetchTradeFeesDataBatch: (contract: GNSMultiCollatDiamond, traders: string[], indices: number[]) => Promise<TradeInitialAccFees[]>;
+/**
+ * @dev Fetches pending accumulated funding fees for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param currentPairPrices Array of current pair prices (1e10)
+ * @returns Promise resolving to array of accumulated funding fees
+ */
+export declare const fetchPairPendingAccFundingFeesBatch: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[], currentPairPrices: bigint[]) => Promise<Array<{
+    accFundingFeeLongP: number;
+    accFundingFeeShortP: number;
+    currentFundingRatePerSecondP: number;
+}>>;
+/**
+ * @dev Helper to convert price from number to contract format
+ * @param price Price as number
+ * @returns Price in contract format (1e10)
+ */
+export declare const priceToContractFormat: (price: number) => bigint;
+/**
+ * @dev Helper to convert collateral amount to contract format
+ * @param amount Amount as number
+ * @param decimals Collateral decimals (6 for USDC, 18 for others)
+ * @returns Amount in contract format
+ */
+export declare const collateralToContractFormat: (amount: number, decimals: number) => bigint;