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

package/lib/markets/holdingFees/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+import { FundingFeeParams, PairFundingFeeData, PairOiAfterV10 } from "../../trade/fees/fundingFees/types";
+import { BorrowingFeeParams, PairBorrowingFeeData } from "../../trade/fees/borrowingV2/types";
+export type HoldingFeeRates = {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+};
+export type GetPairHoldingFeeRatesInput = {
+    fundingParams: FundingFeeParams;
+    fundingData: PairFundingFeeData;
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: BorrowingFeeParams | null;
+    borrowingData: PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+};
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+export declare const getPairHoldingFeeRates: (input: GetPairHoldingFeeRatesInput) => HoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+export declare const convertRatePerSecondToAPR: (ratePerSecond: number) => number;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+export declare const formatHoldingFeeRate: (rate: number, decimals?: number) => string;
+export * as HoldingFees from "./types";

package/lib/markets/holdingFees/index.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoldingFees = exports.formatHoldingFeeRate = exports.convertRatePerSecondToAPR = exports.getPairHoldingFeeRates = void 0;
+const fundingFees_1 = require("../../trade/fees/fundingFees");
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+const PERCENTAGE_PRECISION = 100;
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+const getPairHoldingFeeRates = (input) => {
+    const { fundingParams, fundingData, pairOiToken, netExposureToken, netExposureUsd, borrowingParams, borrowingData, currentPairPrice, currentTimestamp, } = input;
+    // Calculate funding fee rates
+    let fundingFeeLongHourlyRate = 0;
+    let fundingFeeShortHourlyRate = 0;
+    let currentFundingRatePerSecondP = 0;
+    if (fundingParams.fundingFeesEnabled) {
+        // Get current funding rate
+        const pendingFunding = (0, fundingFees_1.getPairPendingAccFundingFees)(fundingParams, fundingData, currentPairPrice, pairOiToken, netExposureToken, netExposureUsd, currentTimestamp);
+        currentFundingRatePerSecondP = pendingFunding.currentFundingRatePerSecondP;
+        // Get APR multipliers
+        const { longAprMultiplier, shortAprMultiplier } = (0, fundingFees_1.getLongShortAprMultiplier)(currentFundingRatePerSecondP, pairOiToken.oiLongToken, pairOiToken.oiShortToken, fundingParams.aprMultiplierEnabled);
+        // Calculate hourly rates
+        // Funding rate * seconds per hour * current price * APR multiplier / 100
+        const baseHourlyRate = (currentFundingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+            PERCENTAGE_PRECISION;
+        // Long side pays when rate is positive, earns when negative
+        fundingFeeLongHourlyRate = baseHourlyRate * longAprMultiplier;
+        // Short side is opposite
+        fundingFeeShortHourlyRate = -baseHourlyRate * shortAprMultiplier;
+    }
+    // Calculate borrowing v2 rates
+    let borrowingFeeHourlyRate = 0;
+    let currentBorrowingRatePerSecondP = 0;
+    if (borrowingParams && borrowingData) {
+        currentBorrowingRatePerSecondP = borrowingParams.borrowingRatePerSecondP;
+        // Borrowing rate * seconds per hour * current price / 100
+        borrowingFeeHourlyRate =
+            (currentBorrowingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+                PERCENTAGE_PRECISION;
+    }
+    // Total holding fees (funding can be negative/positive, borrowing always positive cost)
+    const longHourlyRate = fundingFeeLongHourlyRate + borrowingFeeHourlyRate;
+    const shortHourlyRate = fundingFeeShortHourlyRate + borrowingFeeHourlyRate;
+    return {
+        longHourlyRate,
+        shortHourlyRate,
+        fundingFeeLongHourlyRate,
+        fundingFeeShortHourlyRate,
+        borrowingFeeHourlyRate,
+        currentFundingRatePerSecondP,
+        currentBorrowingRatePerSecondP,
+    };
+};
+exports.getPairHoldingFeeRates = getPairHoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+const convertRatePerSecondToAPR = (ratePerSecond) => {
+    return ratePerSecond * SECONDS_PER_YEAR * PERCENTAGE_PRECISION;
+};
+exports.convertRatePerSecondToAPR = convertRatePerSecondToAPR;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+const formatHoldingFeeRate = (rate, decimals = 4) => {
+    const sign = rate > 0 ? "+" : "";
+    return `${sign}${rate.toFixed(decimals)}%`;
+};
+exports.formatHoldingFeeRate = formatHoldingFeeRate;
+exports.HoldingFees = __importStar(require("./types"));

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

@@ -0,0 +1,23 @@
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+export interface HoldingFeeRates {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+}
+export interface GetPairHoldingFeeRatesInput {
+    fundingParams: import("../../trade/fees/fundingFees/types").FundingFeeParams;
+    fundingData: import("../../trade/fees/fundingFees/types").PairFundingFeeData;
+    pairOiToken: import("../../trade/fees/fundingFees/types").PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: import("../../trade/fees/borrowingV2/types").BorrowingFeeParams | null;
+    borrowingData: import("../../trade/fees/borrowingV2/types").PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+}

package/lib/markets/holdingFees/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/markets/index.d.ts

@@ -6,3 +6,4 @@ export * from "./commodities";
 export * from "./oi";
 export * from "./collateral";
 export * from "./price";
+export * from "./holdingFees";

package/lib/markets/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./commodities"), exports);
 __exportStar(require("./oi"), exports);
 __exportStar(require("./collateral"), exports);
 __exportStar(require("./price"), exports);
+__exportStar(require("./holdingFees"), exports);

package/lib/markets/oi/converter.d.ts

@@ -7,10 +7,9 @@ import { UnifiedPairOi, ComputedOi } from "./types";
 /**
  * @dev Converts pre-v10 OI from contract format
  * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
- * @param precision Collateral precision for conversion
  * @returns Normalized OI with long/short values
  */
-export declare const convertBeforeV10Collateral: (contractOi: IBorrowingFees.OpenInterestStructOutput, precision: number) => {
+export declare const convertBeforeV10Collateral: (contractOi: IBorrowingFees.OpenInterestStructOutput) => {
     long: number;
     short: number;
 };

package/lib/markets/oi/converter.js

@@ -8,13 +8,12 @@ exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = e
 /**
  * @dev Converts pre-v10 OI from contract format
  * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
- * @param precision Collateral precision for conversion
  * @returns Normalized OI with long/short values
  */
-const convertBeforeV10Collateral = (contractOi, precision) => {
+const convertBeforeV10Collateral = (contractOi) => {
     return {
-        long: Number(contractOi.long) / precision,
-        short: Number(contractOi.short) / precision,
+        long: Number(contractOi.long) / 1e10,
+        short: Number(contractOi.short) / 1e10,
     };
 };
 exports.convertBeforeV10Collateral = convertBeforeV10Collateral;
@@ -54,8 +53,8 @@ exports.convertTokenOi = convertTokenOi;
  */
 const convertPairOi = (beforeV10, afterV10Collateral, afterV10Token, collateralPrecision) => {
     return {
-        maxCollateral: Number(beforeV10.max) / collateralPrecision,
-        beforeV10Collateral: (0, exports.convertBeforeV10Collateral)(beforeV10, collateralPrecision),
+        maxCollateral: Number(beforeV10.max) / 1e10,
+        beforeV10Collateral: (0, exports.convertBeforeV10Collateral)(beforeV10),
         collateral: (0, exports.convertCollateralOi)(afterV10Collateral, collateralPrecision),
         token: (0, exports.convertTokenOi)(afterV10Token),
     };

package/lib/markets/oi/index.d.ts

@@ -2,9 +2,48 @@
  * @dev Main export file for OI module
  * @dev Provides unified Open Interest management functionality
  */
-export { UnifiedPairOi, GroupOi, OiUsageMetadata, ComputedOi } from "./types";
+import { GenericPairOiContext } from "./types";
+export declare const getPairTotalOisCollateral: (pairIndex: number, context: GenericPairOiContext) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for long and short sides in collateral precision
+ */
+export declare const getPairTotalOisDynamicCollateral: (pairIndex: number, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens on one side only
+ * @param pairIndex index of pair
+ * @param long true if long, false if short
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for the specified side in collateral precision
+ */
+export declare const getPairTotalOiDynamicCollateral: (pairIndex: number, long: boolean, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => number;
+/**
+ * @dev Returns pair open interest skew (v10 only) in tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array
+ * @returns skew in token amount (positive = more longs, negative = more shorts)
+ */
+export declare const getPairV10OiTokenSkewCollateral: (pairIndex: number, context: GenericPairOiContext) => number;
+/**
+ * @dev Returns pair dynamic skew (v10 only) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic skew in collateral precision
+ */
+export declare const getPairV10OiDynamicSkewCollateral: (pairIndex: number, context: GenericPairOiContext & {
+    currentPairPrice: number;
+}) => number;
+export { UnifiedPairOi, GroupOi, ComputedOi } from "./types";
 export { convertBeforeV10Collateral, convertCollateralOi, convertTokenOi, convertPairOi, convertPairOiArray, computeOiValues, } from "./converter";
-export { fetchPairOi, fetchMultiplePairOi, createOiContext, fetchOiForUseCase, } from "./fetcher";
-export { withinMaxPairOi, calculateDynamicOi, getRemainingOiCapacity, withinMaxGroupOiDynamic, getGroupDynamicOi, validateOiLimits, } from "./validation";
-import { OiUsageMetadata } from "./types";
-export declare const OI_USAGE: OiUsageMetadata;

package/lib/markets/oi/index.js

@@ -4,7 +4,69 @@
  * @dev Provides unified Open Interest management functionality
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OI_USAGE = exports.validateOiLimits = exports.getGroupDynamicOi = exports.withinMaxGroupOiDynamic = exports.getRemainingOiCapacity = exports.calculateDynamicOi = exports.withinMaxPairOi = exports.fetchOiForUseCase = exports.createOiContext = exports.fetchMultiplePairOi = exports.fetchPairOi = exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = void 0;
+exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = exports.getPairV10OiDynamicSkewCollateral = exports.getPairV10OiTokenSkewCollateral = exports.getPairTotalOiDynamicCollateral = exports.getPairTotalOisDynamicCollateral = exports.getPairTotalOisCollateral = void 0;
+const getPairTotalOisCollateral = (pairIndex, context) => {
+    return {
+        long: context.pairOis[pairIndex].beforeV10Collateral.long +
+            context.pairOis[pairIndex].collateral.long,
+        short: context.pairOis[pairIndex].beforeV10Collateral.short +
+            context.pairOis[pairIndex].collateral.short,
+    };
+};
+exports.getPairTotalOisCollateral = getPairTotalOisCollateral;
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for long and short sides in collateral precision
+ */
+const getPairTotalOisDynamicCollateral = (pairIndex, context) => {
+    const pairOi = context.pairOis[pairIndex];
+    // We have to use the initial collateral OIs for pre-v10 trades because we don't have OIs in token amount
+    const oiLongCollateralDynamicAfterV10 = pairOi.beforeV10Collateral.long +
+        pairOi.token.long * context.currentPairPrice;
+    const oiShortCollateralDynamicAfterV10 = pairOi.beforeV10Collateral.short +
+        pairOi.token.short * context.currentPairPrice;
+    return {
+        long: oiLongCollateralDynamicAfterV10,
+        short: oiShortCollateralDynamicAfterV10,
+    };
+};
+exports.getPairTotalOisDynamicCollateral = getPairTotalOisDynamicCollateral;
+/**
+ * @dev Returns pair total dynamic open interest (before v10 + after v10) in collateral tokens on one side only
+ * @param pairIndex index of pair
+ * @param long true if long, false if short
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic OI for the specified side in collateral precision
+ */
+const getPairTotalOiDynamicCollateral = (pairIndex, long, context) => {
+    const dynamicOis = (0, exports.getPairTotalOisDynamicCollateral)(pairIndex, context);
+    return long ? dynamicOis.long : dynamicOis.short;
+};
+exports.getPairTotalOiDynamicCollateral = getPairTotalOiDynamicCollateral;
+/**
+ * @dev Returns pair open interest skew (v10 only) in tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array
+ * @returns skew in token amount (positive = more longs, negative = more shorts)
+ */
+const getPairV10OiTokenSkewCollateral = (pairIndex, context) => {
+    const pairOi = context.pairOis[pairIndex];
+    return pairOi.token.long - pairOi.token.short;
+};
+exports.getPairV10OiTokenSkewCollateral = getPairV10OiTokenSkewCollateral;
+/**
+ * @dev Returns pair dynamic skew (v10 only) in collateral tokens
+ * @param pairIndex index of pair
+ * @param context contains UnifiedPairOi array and current pair price
+ * @returns dynamic skew in collateral precision
+ */
+const getPairV10OiDynamicSkewCollateral = (pairIndex, context) => {
+    return ((0, exports.getPairV10OiTokenSkewCollateral)(pairIndex, context) *
+        context.currentPairPrice);
+};
+exports.getPairV10OiDynamicSkewCollateral = getPairV10OiDynamicSkewCollateral;
 // Converters
 var converter_1 = require("./converter");
 Object.defineProperty(exports, "convertBeforeV10Collateral", { enumerable: true, get: function () { return converter_1.convertBeforeV10Collateral; } });
@@ -13,25 +75,3 @@ Object.defineProperty(exports, "convertTokenOi", { enumerable: true, get: functi
 Object.defineProperty(exports, "convertPairOi", { enumerable: true, get: function () { return converter_1.convertPairOi; } });
 Object.defineProperty(exports, "convertPairOiArray", { enumerable: true, get: function () { return converter_1.convertPairOiArray; } });
 Object.defineProperty(exports, "computeOiValues", { enumerable: true, get: function () { return converter_1.computeOiValues; } });
-// Fetchers
-var fetcher_1 = require("./fetcher");
-Object.defineProperty(exports, "fetchPairOi", { enumerable: true, get: function () { return fetcher_1.fetchPairOi; } });
-Object.defineProperty(exports, "fetchMultiplePairOi", { enumerable: true, get: function () { return fetcher_1.fetchMultiplePairOi; } });
-Object.defineProperty(exports, "createOiContext", { enumerable: true, get: function () { return fetcher_1.createOiContext; } });
-Object.defineProperty(exports, "fetchOiForUseCase", { enumerable: true, get: function () { return fetcher_1.fetchOiForUseCase; } });
-// Validation
-var validation_1 = require("./validation");
-Object.defineProperty(exports, "withinMaxPairOi", { enumerable: true, get: function () { return validation_1.withinMaxPairOi; } });
-Object.defineProperty(exports, "calculateDynamicOi", { enumerable: true, get: function () { return validation_1.calculateDynamicOi; } });
-Object.defineProperty(exports, "getRemainingOiCapacity", { enumerable: true, get: function () { return validation_1.getRemainingOiCapacity; } });
-Object.defineProperty(exports, "withinMaxGroupOiDynamic", { enumerable: true, get: function () { return validation_1.withinMaxGroupOiDynamic; } });
-Object.defineProperty(exports, "getGroupDynamicOi", { enumerable: true, get: function () { return validation_1.getGroupDynamicOi; } });
-Object.defineProperty(exports, "validateOiLimits", { enumerable: true, get: function () { return validation_1.validateOiLimits; } });
-exports.OI_USAGE = {
-    borrowingV1: ["beforeV10Collateral", "token"],
-    fundingFees: ["token"],
-    skewImpact: ["token"],
-    maxPairOi: ["beforeV10Collateral", "token"],
-    maxGroupOi: ["beforeV10Collateral", "token"],
-    maxSkew: ["token"], // V10+ only: uses token OI
-};

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

@@ -37,23 +37,14 @@ export interface UnifiedPairOi {
         short: number;
     };
 }
+export type GenericPairOiContext = {
+    pairOis: UnifiedPairOi[];
+};
 /**
  * @dev Group OI remains unchanged - only used by borrowing v1
  * @dev Re-export existing type for consistency
  */
 export { OpenInterest as GroupOi } from "../../trade/types";
-/**
- * @dev Metadata describing which OI systems are used by different features
- * @dev Helps consumers understand OI usage patterns
- */
-export interface OiUsageMetadata {
-    borrowingV1: Array<"beforeV10Collateral" | "token">;
-    fundingFees: Array<"token">;
-    skewImpact: Array<"token">;
-    maxPairOi: Array<"beforeV10Collateral" | "token">;
-    maxGroupOi: Array<"beforeV10Collateral" | "token">;
-    maxSkew: Array<"token">;
-}
 /**
  * @dev Helper type for computed OI values
  */

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

@@ -0,0 +1,46 @@
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+import { FundingFeeParams, PairFundingFeeData, PairOiAfterV10 } from "../fundingFees/types";
+import { BorrowingFeeParams, PairBorrowingFeeData } from "../borrowingV2/types";
+export type HoldingFeeRates = {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+};
+export type GetPairHoldingFeeRatesInput = {
+    fundingParams: FundingFeeParams;
+    fundingData: PairFundingFeeData;
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: BorrowingFeeParams | null;
+    borrowingData: PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+};
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+export declare const getPairHoldingFeeRates: (input: GetPairHoldingFeeRatesInput) => HoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+export declare const convertRatePerSecondToAPR: (ratePerSecond: number) => number;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+export declare const formatHoldingFeeRate: (rate: number, decimals?: number) => string;
+export * as HoldingFees from "./types";

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

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoldingFees = exports.formatHoldingFeeRate = exports.convertRatePerSecondToAPR = exports.getPairHoldingFeeRates = void 0;
+const fundingFees_1 = require("../fundingFees");
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+const PERCENTAGE_PRECISION = 100;
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+const getPairHoldingFeeRates = (input) => {
+    const { fundingParams, fundingData, pairOiToken, netExposureToken, netExposureUsd, borrowingParams, borrowingData, currentPairPrice, currentTimestamp, } = input;
+    // Calculate funding fee rates
+    let fundingFeeLongHourlyRate = 0;
+    let fundingFeeShortHourlyRate = 0;
+    let currentFundingRatePerSecondP = 0;
+    if (fundingParams.fundingFeesEnabled) {
+        // Get current funding rate
+        const pendingFunding = (0, fundingFees_1.getPairPendingAccFundingFees)(fundingParams, fundingData, currentPairPrice, pairOiToken, netExposureToken, netExposureUsd, currentTimestamp);
+        currentFundingRatePerSecondP = pendingFunding.currentFundingRatePerSecondP;
+        // Get APR multipliers
+        const { longAprMultiplier, shortAprMultiplier } = (0, fundingFees_1.getLongShortAprMultiplier)(currentFundingRatePerSecondP, pairOiToken.oiLongToken, pairOiToken.oiShortToken, fundingParams.aprMultiplierEnabled);
+        // Calculate hourly rates
+        // Funding rate * seconds per hour * current price * APR multiplier / 100
+        const baseHourlyRate = (currentFundingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+            PERCENTAGE_PRECISION;
+        // Long side pays when rate is positive, earns when negative
+        fundingFeeLongHourlyRate = baseHourlyRate * longAprMultiplier;
+        // Short side is opposite
+        fundingFeeShortHourlyRate = -baseHourlyRate * shortAprMultiplier;
+    }
+    // Calculate borrowing v2 rates
+    let borrowingFeeHourlyRate = 0;
+    let currentBorrowingRatePerSecondP = 0;
+    if (borrowingParams && borrowingData) {
+        currentBorrowingRatePerSecondP = borrowingParams.borrowingRatePerSecondP;
+        // Borrowing rate * seconds per hour * current price / 100
+        borrowingFeeHourlyRate =
+            (currentBorrowingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+                PERCENTAGE_PRECISION;
+    }
+    // Total holding fees (funding can be negative/positive, borrowing always positive cost)
+    const longHourlyRate = fundingFeeLongHourlyRate + borrowingFeeHourlyRate;
+    const shortHourlyRate = fundingFeeShortHourlyRate + borrowingFeeHourlyRate;
+    return {
+        longHourlyRate,
+        shortHourlyRate,
+        fundingFeeLongHourlyRate,
+        fundingFeeShortHourlyRate,
+        borrowingFeeHourlyRate,
+        currentFundingRatePerSecondP,
+        currentBorrowingRatePerSecondP,
+    };
+};
+exports.getPairHoldingFeeRates = getPairHoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+const convertRatePerSecondToAPR = (ratePerSecond) => {
+    return ratePerSecond * SECONDS_PER_YEAR * PERCENTAGE_PRECISION;
+};
+exports.convertRatePerSecondToAPR = convertRatePerSecondToAPR;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+const formatHoldingFeeRate = (rate, decimals = 4) => {
+    const sign = rate > 0 ? "+" : "";
+    return `${sign}${rate.toFixed(decimals)}%`;
+};
+exports.formatHoldingFeeRate = formatHoldingFeeRate;
+exports.HoldingFees = __importStar(require("./types"));

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

@@ -0,0 +1,23 @@
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+export interface HoldingFeeRates {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+}
+export interface GetPairHoldingFeeRatesInput {
+    fundingParams: import("../fundingFees/types").FundingFeeParams;
+    fundingData: import("../fundingFees/types").PairFundingFeeData;
+    pairOiToken: import("../fundingFees/types").PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: import("../borrowingV2/types").BorrowingFeeParams | null;
+    borrowingData: import("../borrowingV2/types").PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+}

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,6 +1,7 @@
 export * from "./borrowing";
 export * from "./tiers";
 export * from "./trading";
+export * from "../../markets/holdingFees";
 export { convertTradeFeesData, convertTradeFeesDataArray, convertUiRealizedPnlData, convertUiRealizedPnlDataArray, encodeTradeFeesData, encodeUiRealizedPnlData, } from "./converter";
 export { BorrowingFeeV2, borrowingFeeV2Utils, getPairPendingAccBorrowingFees as getPairPendingAccBorrowingFeesV2, getTradeBorrowingFeesCollateral as getTradeBorrowingFeesCollateralV2, getPairBorrowingFees as getPairBorrowingFeesV2, MAX_BORROWING_RATE_PER_SECOND as MAX_BORROWING_RATE_PER_SECOND_V2, BORROWING_V2_PRECISION, } from "./borrowingV2";
 export { convertBorrowingFeeParams as convertBorrowingFeeParamsV2, convertBorrowingFeeParamsArray as convertBorrowingFeeParamsArrayV2, convertPairBorrowingFeeData as convertPairBorrowingFeeDataV2, convertPairBorrowingFeeDataArray as convertPairBorrowingFeeDataArrayV2, convertTradeInitialAccFees as convertTradeInitialAccFeesV2, convertTradeInitialAccFeesArray as convertTradeInitialAccFeesArrayV2, createBorrowingV2Context, isValidBorrowingRate as isValidBorrowingRateV2, borrowingRateToAPR as borrowingRateToAPRV2, aprToBorrowingRate as aprToBorrowingRateV2, } from "./borrowingV2/converter";

package/lib/trade/fees/index.js

@@ -19,6 +19,7 @@ exports.FUNDING_FEES_PRECISION = exports.calculateVelocityFromSkew = exports.apr
 __exportStar(require("./borrowing"), exports);
 __exportStar(require("./tiers"), exports);
 __exportStar(require("./trading"), exports);
+__exportStar(require("../../markets/holdingFees"), exports);
 // TradeFeesData and UiRealizedPnlData converters
 var converter_1 = require("./converter");
 Object.defineProperty(exports, "convertTradeFeesData", { enumerable: true, get: function () { return converter_1.convertTradeFeesData; } });

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

@@ -2,10 +2,21 @@
  * @dev PnL calculation module
  * @dev Provides functions matching v10 contract implementations
  */
-import { Trade, TradeInfo, LiquidationParams, Fee, GlobalTradeFeeParams } from "../types";
+import { Trade, TradeInfo, LiquidationParams, Fee, GlobalTradeFeeParams, TradeFeesData } from "../types";
 import { ComprehensivePnlResult, GetComprehensivePnlContext } from "./types";
 import { BorrowingFee } from "../fees/borrowing";
 import { ContractsVersion } from "../../contracts/types";
+/**
+ * @dev Gets trade realized PnL components from TradeFeesData
+ * @dev Mirrors contract's getTradeRealizedPnlCollateral function
+ * @param tradeFeesData Trade fees data containing realized components
+ * @returns Tuple of [realizedPnlCollateral, realizedTradingFeesCollateral, totalRealizedPnlCollateral]
+ */
+export declare const getTradeRealizedPnlCollateral: (tradeFeesData: TradeFeesData) => {
+    realizedPnlCollateral: number;
+    realizedTradingFeesCollateral: number;
+    totalRealizedPnlCollateral: number;
+};
 /**
  * @dev Calculates PnL percentage for a position
  * @dev Mirrors contract's getPnlPercent function

package/lib/trade/pnl/index.js

@@ -18,10 +18,27 @@ 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.getPriceForTargetPnlPercentage = exports.getPnl = exports.getComprehensivePnl = exports.getTradeValue = exports.getPnlPercent = void 0;
+exports.getPriceForTargetPnlPercentage = exports.getPnl = exports.getComprehensivePnl = exports.getTradeValue = exports.getPnlPercent = exports.getTradeRealizedPnlCollateral = void 0;
 const borrowing_1 = require("../fees/borrowing");
 const trading_1 = require("../fees/trading");
 const liquidation_1 = require("../liquidation");
+/**
+ * @dev Gets trade realized PnL components from TradeFeesData
+ * @dev Mirrors contract's getTradeRealizedPnlCollateral function
+ * @param tradeFeesData Trade fees data containing realized components
+ * @returns Tuple of [realizedPnlCollateral, realizedTradingFeesCollateral, totalRealizedPnlCollateral]
+ */
+const getTradeRealizedPnlCollateral = (tradeFeesData) => {
+    const realizedPnlCollateral = tradeFeesData.realizedPnlCollateral;
+    const realizedTradingFeesCollateral = tradeFeesData.realizedTradingFeesCollateral;
+    const totalRealizedPnlCollateral = realizedPnlCollateral - realizedTradingFeesCollateral;
+    return {
+        realizedPnlCollateral,
+        realizedTradingFeesCollateral,
+        totalRealizedPnlCollateral,
+    };
+};
+exports.getTradeRealizedPnlCollateral = getTradeRealizedPnlCollateral;
 /**
  * @dev Calculates PnL percentage for a position
  * @dev Mirrors contract's getPnlPercent function
@@ -93,7 +110,8 @@ const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
         traderFeeMultiplier: context.trading.traderFeeMultiplier,
     });
     // Total fees
-    const totalFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee + closingFee;
+    const totalHoldingFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee;
+    const totalFees = totalHoldingFees + closingFee;
     // Check liquidation
     const liquidationThreshold = ((_a = context.tradeData) === null || _a === void 0 ? void 0 : _a.liquidationParams)
         ? (0, liquidation_1.getLiqPnlThresholdP)(context.tradeData.liquidationParams, trade.leverage) *
@@ -104,20 +122,19 @@ const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
     if (isLiquidated) {
         pnlPercent = -100;
     }
+    // Get realized PnL components from TradeFeesData
+    const { totalRealizedPnlCollateral } = (0, exports.getTradeRealizedPnlCollateral)(context.tradeData.tradeFeesData);
     // Calculate final trade value
     const tradeValue = (0, exports.getTradeValue)(trade.collateralAmount, pnlPercent, totalFees);
     // Calculate PnL in collateral
     const pnlCollateral = trade.collateralAmount * (pnlPercent / 100);
     // Calculate leveraged position size
     const leveragedPositionSize = trade.collateralAmount * trade.leverage;
-    // Calculate net PnL after fees
-    const netPnlAfterFees = pnlCollateral - totalFees;
     // Calculate unrealized PnL (before closing fee, after holding fees)
-    const totalHoldingFees = borrowingFeeV1 + borrowingFeeV2 + fundingFee;
-    const uPnlCollateral = pnlCollateral - totalHoldingFees;
+    const uPnlCollateral = pnlCollateral - totalHoldingFees + totalRealizedPnlCollateral;
     const uPnlPercent = (uPnlCollateral / trade.collateralAmount) * 100;
     // Realized PnL (after all fees including closing)
-    const realizedPnlCollateral = pnlCollateral - totalFees;
+    const realizedPnlCollateral = pnlCollateral - totalFees + totalRealizedPnlCollateral;
     const realizedPnlPercent = (realizedPnlCollateral / trade.collateralAmount) * 100;
     return {
         // Core PnL values
@@ -143,7 +160,6 @@ const getComprehensivePnl = (trade, currentPrice, tradeInfo, context) => {
         isProfitable: pnlPercent > 0,
         // Additional info
         leveragedPositionSize,
-        netPnlAfterFees,
     };
 };
 exports.getComprehensivePnl = getComprehensivePnl;

package/lib/trade/pnl/types.d.ts

@@ -52,7 +52,6 @@ export type ComprehensivePnlResult = {
     isLiquidated: boolean;
     isProfitable: boolean;
     leveragedPositionSize: number;
-    netPnlAfterFees: number;
 };
 /**
  * @dev Context for comprehensive PnL calculations with nested sub-contexts

package/lib/trade/priceImpact/close/index.js

@@ -12,17 +12,20 @@ const types_1 = require("../../../contracts/types");
 var builder_1 = require("./builder");
 Object.defineProperty(exports, "buildTradeClosingPriceImpactContext", { enumerable: true, get: function () { return builder_1.buildTradeClosingPriceImpactContext; } });
 /**
- * @dev Calculates position size in tokens for partial close
- * @param originalPositionSizeToken Original position size in tokens
+ * @dev Calculates position size in tokens for the portion being closed
+ * @param positionSizeCollateral Position size in collateral units being closed
+ * @param originalPositionSizeToken Original total position size in tokens
  * @param originalCollateral Original collateral amount
- * @param closingCollateral Collateral amount being closed
- * @returns Proportional position size in tokens
+ * @param originalLeverage Original leverage
+ * @returns Position size in tokens for the closing portion
  */
-const calculateClosingPositionSizeToken = (originalPositionSizeToken, originalCollateral, closingCollateral) => {
-    if (originalCollateral === 0)
+const calculateClosingPositionSizeToken = (positionSizeCollateral, originalPositionSizeToken, originalCollateral, originalLeverage) => {
+    const totalPositionSizeCollateral = originalCollateral * originalLeverage;
+    if (totalPositionSizeCollateral === 0)
         return 0;
-    // Proportional calculation: (closingCollateral / originalCollateral) * originalPositionSizeToken
-    return (closingCollateral * originalPositionSizeToken) / originalCollateral;
+    // Match contract logic: (positionSizeCollateral * originalPositionSizeToken) / totalPositionSizeCollateral
+    return ((positionSizeCollateral * originalPositionSizeToken) /
+        totalPositionSizeCollateral);
 };
 /**
  * @dev Calculates all price impacts for trade closing
@@ -46,7 +49,7 @@ const getTradeClosingPriceImpact = (input, context) => {
     }
     // Calculate position size in tokens (proportional to collateral being closed)
     const positionSizeToken = input.trade.positionSizeToken
-        ? calculateClosingPositionSizeToken(input.trade.positionSizeToken, input.trade.collateralAmount, input.positionSizeCollateral)
+        ? calculateClosingPositionSizeToken(input.positionSizeCollateral, input.trade.positionSizeToken, input.trade.collateralAmount, input.trade.leverage)
         : 0;
     // Calculate fixed spread (reversed for closing)
     const fixedSpreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.trade.long, false // closing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.0.0-v10.rc10",
+  "version": "0.0.0-v10.rc14",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [