@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc1

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

@@ -0,0 +1,309 @@
+"use strict";
+/**
+ * @dev Funding fees calculations for v10+ trades
+ * @dev Based on skew-based funding rate model with velocity and APR multipliers
+ */
+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.FundingFees = exports.getTradeFundingFeesCollateralSimple = exports.getTradeFundingFees = exports.getTradeFundingFeesCollateral = exports.getPairPendingAccFundingFees = exports.getLongShortAprMultiplier = exports.getAvgFundingRatePerSecondP = exports.getSecondsToReachZeroRate = exports.getCurrentFundingVelocityPerYear = void 0;
+const types_1 = require("../../../contracts/types");
+// Constants from contract
+const FUNDING_APR_MULTIPLIER_CAP = 100; // Smaller side can earn up to 100x more APR
+const ONE_YEAR = 365 * 24 * 60 * 60; // 1 year in seconds
+/**
+ * @dev Calculates current funding velocity per year based on skew
+ * @param netExposureToken Net exposure (long - short) in tokens
+ * @param netExposureUsd Net exposure in USD
+ * @param skewCoefficientPerYear Skew coefficient per year from params
+ * @param absoluteVelocityPerYearCap Cap on velocity per year
+ * @param thetaThresholdUsd Minimum exposure USD to start charging funding fees
+ * @returns Current yearly funding velocity
+ */
+const getCurrentFundingVelocityPerYear = (netExposureToken, netExposureUsd, skewCoefficientPerYear, absoluteVelocityPerYearCap, thetaThresholdUsd) => {
+    // If no exposure or skew coefficient 0 or velocity cap 0, velocity is 0
+    if (netExposureToken === 0 ||
+        skewCoefficientPerYear === 0 ||
+        absoluteVelocityPerYearCap === 0) {
+        return 0;
+    }
+    // Check theta threshold
+    const absNetExposureUsd = Math.abs(netExposureUsd);
+    if (absNetExposureUsd < thetaThresholdUsd) {
+        return 0;
+    }
+    // Calculate absolute velocity
+    const absoluteVelocityPerYear = Math.abs(netExposureToken) * skewCoefficientPerYear;
+    // Apply cap
+    const cappedAbsoluteVelocity = Math.min(absoluteVelocityPerYear, absoluteVelocityPerYearCap);
+    // Return with proper sign
+    return netExposureToken < 0
+        ? -cappedAbsoluteVelocity
+        : cappedAbsoluteVelocity;
+};
+exports.getCurrentFundingVelocityPerYear = getCurrentFundingVelocityPerYear;
+/**
+ * @dev Calculates seconds until funding rate reaches zero
+ * @param lastFundingRatePerSecondP Last funding rate per second
+ * @param currentVelocityPerYear Current velocity per year
+ * @returns Seconds until rate reaches zero
+ */
+const getSecondsToReachZeroRate = (lastFundingRatePerSecondP, currentVelocityPerYear) => {
+    if (currentVelocityPerYear === 0) {
+        throw new Error("Velocity cannot be zero when calculating time to reach zero rate");
+    }
+    const secondsToReachZeroRate = (-lastFundingRatePerSecondP * ONE_YEAR) / currentVelocityPerYear;
+    if (secondsToReachZeroRate < 0) {
+        throw new Error("Invalid calculation: seconds to reach zero rate cannot be negative");
+    }
+    return secondsToReachZeroRate;
+};
+exports.getSecondsToReachZeroRate = getSecondsToReachZeroRate;
+/**
+ * @dev Calculates average and current funding rate per second
+ * @param lastFundingRatePerSecondP Last funding rate per second
+ * @param absoluteRatePerSecondCap Absolute cap on funding rate per second
+ * @param currentVelocityPerYear Current velocity per year
+ * @param secondsSinceLastUpdate Seconds elapsed since last update
+ * @returns Average and current funding rate per second
+ */
+const getAvgFundingRatePerSecondP = (lastFundingRatePerSecondP, absoluteRatePerSecondCap, currentVelocityPerYear, secondsSinceLastUpdate) => {
+    // If cap is 0, there are no funding fees
+    if (absoluteRatePerSecondCap === 0) {
+        return { avgFundingRatePerSecondP: 0, currentFundingRatePerSecondP: 0 };
+    }
+    // If velocity is 0 or no time elapsed, funding rate is still the same
+    if (currentVelocityPerYear === 0 || secondsSinceLastUpdate === 0) {
+        return {
+            avgFundingRatePerSecondP: lastFundingRatePerSecondP,
+            currentFundingRatePerSecondP: lastFundingRatePerSecondP,
+        };
+    }
+    const ratePerSecondCap = absoluteRatePerSecondCap * (currentVelocityPerYear < 0 ? -1 : 1);
+    // If rate is already at cap, just return it
+    if (ratePerSecondCap === lastFundingRatePerSecondP) {
+        return {
+            avgFundingRatePerSecondP: ratePerSecondCap,
+            currentFundingRatePerSecondP: ratePerSecondCap,
+        };
+    }
+    const secondsToReachCap = ((ratePerSecondCap - lastFundingRatePerSecondP) * ONE_YEAR) /
+        currentVelocityPerYear;
+    if (secondsSinceLastUpdate > secondsToReachCap) {
+        // Rate reached cap during this period
+        const currentFundingRatePerSecondP = ratePerSecondCap;
+        // Weighted average: time to cap at average rate + time at cap
+        const avgFundingRatePerSecondP_1 = (lastFundingRatePerSecondP + ratePerSecondCap) / 2;
+        const avgFundingRatePerSecondP = (avgFundingRatePerSecondP_1 * secondsToReachCap +
+            ratePerSecondCap * (secondsSinceLastUpdate - secondsToReachCap)) /
+            secondsSinceLastUpdate;
+        return { avgFundingRatePerSecondP, currentFundingRatePerSecondP };
+    }
+    else {
+        // Rate didn't reach cap
+        const currentFundingRatePerSecondP = lastFundingRatePerSecondP +
+            (secondsSinceLastUpdate * currentVelocityPerYear) / ONE_YEAR;
+        const avgFundingRatePerSecondP = (lastFundingRatePerSecondP + currentFundingRatePerSecondP) / 2;
+        return { avgFundingRatePerSecondP, currentFundingRatePerSecondP };
+    }
+};
+exports.getAvgFundingRatePerSecondP = getAvgFundingRatePerSecondP;
+/**
+ * @dev Calculates APR multipliers for long and short sides based on OI ratio
+ * @param avgFundingRatePerSecondP Average funding rate per second
+ * @param pairOiLongToken Long OI in tokens
+ * @param pairOiShortToken Short OI in tokens
+ * @param aprMultiplierEnabled Whether APR multiplier is enabled
+ * @returns Long and short APR multipliers
+ */
+const getLongShortAprMultiplier = (avgFundingRatePerSecondP, pairOiLongToken, pairOiShortToken, aprMultiplierEnabled) => {
+    // If funding rate is 0, multipliers don't matter
+    if (avgFundingRatePerSecondP === 0) {
+        return { longAprMultiplier: 1, shortAprMultiplier: 1 };
+    }
+    const longsEarned = avgFundingRatePerSecondP < 0;
+    let longAprMultiplier = 1;
+    let shortAprMultiplier = 1;
+    if (aprMultiplierEnabled) {
+        if (longsEarned && pairOiLongToken > 0) {
+            longAprMultiplier = pairOiShortToken / pairOiLongToken;
+        }
+        else if (!longsEarned && pairOiShortToken > 0) {
+            shortAprMultiplier = pairOiLongToken / pairOiShortToken;
+        }
+        // Apply cap
+        longAprMultiplier = Math.min(longAprMultiplier, FUNDING_APR_MULTIPLIER_CAP);
+        shortAprMultiplier = Math.min(shortAprMultiplier, FUNDING_APR_MULTIPLIER_CAP);
+    }
+    return { longAprMultiplier, shortAprMultiplier };
+};
+exports.getLongShortAprMultiplier = getLongShortAprMultiplier;
+/**
+ * @dev Calculates pending accumulated funding fees for a pair
+ * @param params Funding fee parameters
+ * @param data Current funding fee data
+ * @param currentPairPrice Current pair price
+ * @param pairOiToken Pair OI after v10
+ * @param netExposureToken Net exposure in tokens
+ * @param netExposureUsd Net exposure in USD
+ * @param currentTimestamp Current timestamp
+ * @returns Pending accumulated funding fees and current rate
+ */
+const getPairPendingAccFundingFees = (params, data, currentPairPrice, pairOiToken, netExposureToken, netExposureUsd, currentTimestamp) => {
+    let accFundingFeeLongP = data.accFundingFeeLongP;
+    let accFundingFeeShortP = data.accFundingFeeShortP;
+    // If funding fees are disabled, return current values
+    if (!params.fundingFeesEnabled) {
+        return {
+            accFundingFeeLongP,
+            accFundingFeeShortP,
+            currentFundingRatePerSecondP: data.lastFundingRatePerSecondP,
+        };
+    }
+    const secondsSinceLastUpdate = currentTimestamp - data.lastFundingUpdateTs;
+    // Calculate current velocity
+    const currentVelocityPerYear = (0, exports.getCurrentFundingVelocityPerYear)(netExposureToken, netExposureUsd, params.skewCoefficientPerYear, params.absoluteVelocityPerYearCap, params.thetaThresholdUsd);
+    // Get average and current funding rates
+    const { avgFundingRatePerSecondP, currentFundingRatePerSecondP } = (0, exports.getAvgFundingRatePerSecondP)(data.lastFundingRatePerSecondP, params.absoluteRatePerSecondCap, currentVelocityPerYear, secondsSinceLastUpdate);
+    // Check if we need to handle rate sign change
+    const rateChangedSign = params.aprMultiplierEnabled &&
+        ((currentFundingRatePerSecondP > 0 && data.lastFundingRatePerSecondP < 0) ||
+            (currentFundingRatePerSecondP < 0 && data.lastFundingRatePerSecondP > 0));
+    if (rateChangedSign) {
+        // Split calculation into two periods: before and after sign change
+        // 1. From last update to rate = 0
+        const secondsToReachZeroRate = (0, exports.getSecondsToReachZeroRate)(data.lastFundingRatePerSecondP, currentVelocityPerYear);
+        const avgFundingRatePerSecondP_1 = data.lastFundingRatePerSecondP / 2;
+        const fundingFeesDeltaP_1 = avgFundingRatePerSecondP_1 * secondsToReachZeroRate * currentPairPrice;
+        const { longAprMultiplier: longMultiplier1, shortAprMultiplier: shortMultiplier1, } = (0, exports.getLongShortAprMultiplier)(avgFundingRatePerSecondP_1, pairOiToken.oiLongToken, pairOiToken.oiShortToken, true);
+        accFundingFeeLongP += fundingFeesDeltaP_1 * longMultiplier1;
+        accFundingFeeShortP -= fundingFeesDeltaP_1 * shortMultiplier1;
+        // 2. From rate = 0 to current rate
+        const avgFundingRatePerSecondP_2 = currentFundingRatePerSecondP / 2;
+        const fundingFeesDeltaP_2 = avgFundingRatePerSecondP_2 *
+            (secondsSinceLastUpdate - secondsToReachZeroRate) *
+            currentPairPrice;
+        const { longAprMultiplier: longMultiplier2, shortAprMultiplier: shortMultiplier2, } = (0, exports.getLongShortAprMultiplier)(avgFundingRatePerSecondP_2, pairOiToken.oiLongToken, pairOiToken.oiShortToken, true);
+        accFundingFeeLongP += fundingFeesDeltaP_2 * longMultiplier2;
+        accFundingFeeShortP -= fundingFeesDeltaP_2 * shortMultiplier2;
+    }
+    else {
+        // Single period calculation
+        const fundingFeesDeltaP = avgFundingRatePerSecondP * secondsSinceLastUpdate * currentPairPrice;
+        const { longAprMultiplier, shortAprMultiplier } = (0, exports.getLongShortAprMultiplier)(avgFundingRatePerSecondP, pairOiToken.oiLongToken, pairOiToken.oiShortToken, params.aprMultiplierEnabled);
+        accFundingFeeLongP += fundingFeesDeltaP * longAprMultiplier;
+        accFundingFeeShortP -= fundingFeesDeltaP * shortAprMultiplier;
+    }
+    return {
+        accFundingFeeLongP,
+        accFundingFeeShortP,
+        currentFundingRatePerSecondP,
+    };
+};
+exports.getPairPendingAccFundingFees = getPairPendingAccFundingFees;
+/**
+ * @dev Calculates funding fees for a specific trade
+ * @param trade Trade parameters (collateral amount, leverage, open price, long/short)
+ * @param tradeInfo Trade info (contracts version)
+ * @param tradeFeesData Trade fees data containing initial acc funding fee
+ * @param currentPairPrice Current pair price
+ * @param context Pair-specific funding fee context
+ * @returns Funding fee in collateral tokens
+ */
+const getTradeFundingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    if (tradeInfo.contractsVersion < types_1.ContractsVersion.V10) {
+        return 0;
+    }
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    if (!context.params.fundingFeesEnabled) {
+        return 0;
+    }
+    // Calculate pending accumulated fees
+    const { accFundingFeeLongP, accFundingFeeShortP } = (0, exports.getPairPendingAccFundingFees)(context.params, context.data, currentPairPrice, context.pairOi || { oiLongToken: 0, oiShortToken: 0 }, context.netExposureToken || 0, context.netExposureUsd || 0, context.currentTimestamp);
+    const currentAccFundingFeeP = trade.long
+        ? accFundingFeeLongP
+        : accFundingFeeShortP;
+    const fundingFeeDelta = currentAccFundingFeeP - tradeFeesData.initialAccFundingFeeP;
+    return (positionSizeCollateral * fundingFeeDelta) / trade.openPrice / 100;
+};
+exports.getTradeFundingFeesCollateral = getTradeFundingFeesCollateral;
+/**
+ * @dev Main function to calculate funding fees for a trade within context
+ * @param input Trade funding fee input parameters
+ * @param context Funding fee context with params and data
+ * @returns Complete funding fee calculation result
+ */
+const getTradeFundingFees = (input, context) => {
+    var _a, _b;
+    // Get params and data from context
+    const params = (_a = context.fundingParams[input.collateralIndex]) === null || _a === void 0 ? void 0 : _a[input.pairIndex];
+    const data = (_b = context.fundingData[input.collateralIndex]) === null || _b === void 0 ? void 0 : _b[input.pairIndex];
+    if (!params || !data) {
+        throw new Error(`Missing funding fee data for collateral ${input.collateralIndex} pair ${input.pairIndex}`);
+    }
+    // Calculate pending accumulated fees
+    const { accFundingFeeLongP, accFundingFeeShortP } = (0, exports.getPairPendingAccFundingFees)(params, data, input.currentPairPrice, input.pairOiToken, input.netExposureToken, input.netExposureUsd, context.currentTimestamp);
+    const currentAccFundingFeeP = input.trade.long
+        ? accFundingFeeLongP
+        : accFundingFeeShortP;
+    // Calculate funding fee in collateral
+    const fundingFeeCollateral = (0, exports.getTradeFundingFeesCollateralSimple)(input.trade, input.tradeInfo, input.initialAccFundingFeeP, currentAccFundingFeeP);
+    // Calculate funding fee as percentage
+    const fundingFeeP = input.trade.collateralAmount > 0
+        ? (fundingFeeCollateral / input.trade.collateralAmount) * 100
+        : 0;
+    return {
+        fundingFeeCollateral,
+        fundingFeeP,
+        currentAccFundingFeeP,
+        initialAccFundingFeeP: input.initialAccFundingFeeP,
+    };
+};
+exports.getTradeFundingFees = getTradeFundingFees;
+/**
+ * @dev Simple version of getTradeFundingFeesCollateral for backward compatibility
+ * @param trade Trade parameters
+ * @param tradeInfo Trade info with contracts version
+ * @param initialAccFundingFeeP Initial accumulated funding fee
+ * @param currentAccFundingFeeP Current accumulated funding fee
+ * @returns Funding fee in collateral tokens
+ */
+const getTradeFundingFeesCollateralSimple = (trade, tradeInfo, initialAccFundingFeeP, currentAccFundingFeeP) => {
+    // Funding fees are only charged on post-v10 trades
+    if (tradeInfo.contractsVersion < types_1.ContractsVersion.V10) {
+        return 0;
+    }
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    const fundingFeeDelta = currentAccFundingFeeP - initialAccFundingFeeP;
+    return (positionSizeCollateral * fundingFeeDelta) / trade.openPrice / 100;
+};
+exports.getTradeFundingFeesCollateralSimple = getTradeFundingFeesCollateralSimple;
+// Export namespace for types
+exports.FundingFees = __importStar(require("./types"));
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./pairContext"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,33 @@
+/**
+ * @dev Pair-specific funding fee types and utilities
+ */
+import { FundingFeeParams, PairFundingFeeData, PairGlobalParams, PairOiAfterV10, PairPendingAccFundingFeesResult } from "./types";
+/**
+ * @dev Context for pair-specific funding fee calculations
+ */
+export type GetPairFundingFeeContext = {
+    currentTimestamp: number;
+    params: FundingFeeParams;
+    data: PairFundingFeeData;
+    globalParams?: PairGlobalParams;
+    pairOi?: PairOiAfterV10;
+    netExposureToken?: number;
+    netExposureUsd?: number;
+};
+/**
+ * @dev Input for pair-specific trade funding fee calculation
+ */
+export type PairTradeFundingFeeInput = {
+    positionSizeCollateral: number;
+    openPrice: number;
+    long: boolean;
+    currentPairPrice: number;
+    initialAccFundingFeeP: number;
+};
+/**
+ * @dev Calculate pending accumulated funding fees for a pair using pair-specific context
+ * @param currentPairPrice Current price of the pair
+ * @param context Pair-specific funding context
+ * @returns Pending accumulated funding fees
+ */
+export declare const getPairPendingAccFundingFees: (currentPairPrice: number, context: GetPairFundingFeeContext) => PairPendingAccFundingFeesResult;

package/lib/trade/fees/fundingFees/pairContext.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @dev Pair-specific funding fee types and utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPairPendingAccFundingFees = void 0;
+const index_1 = require("./index");
+/**
+ * @dev Calculate pending accumulated funding fees for a pair using pair-specific context
+ * @param currentPairPrice Current price of the pair
+ * @param context Pair-specific funding context
+ * @returns Pending accumulated funding fees
+ */
+const getPairPendingAccFundingFees = (currentPairPrice, context) => {
+    return (0, index_1.getPairPendingAccFundingFees)(context.params, context.data, currentPairPrice, context.pairOi || { oiLongToken: 0, oiShortToken: 0 }, context.netExposureToken || 0, context.netExposureUsd || 0, context.currentTimestamp);
+};
+exports.getPairPendingAccFundingFees = getPairPendingAccFundingFees;

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

@@ -0,0 +1,77 @@
+/**
+ * @dev Funding fees types for v10+ trades
+ */
+export type FundingFeeParams = {
+    skewCoefficientPerYear: number;
+    absoluteVelocityPerYearCap: number;
+    absoluteRatePerSecondCap: number;
+    thetaThresholdUsd: number;
+    fundingFeesEnabled: boolean;
+    aprMultiplierEnabled: boolean;
+};
+export type PairFundingFeeData = {
+    accFundingFeeLongP: number;
+    accFundingFeeShortP: number;
+    lastFundingRatePerSecondP: number;
+    lastFundingUpdateTs: number;
+};
+export type PairGlobalParams = {
+    maxSkewCollateral: number;
+};
+export type TradeInitialAccFundingFees = {
+    initialAccFundingFeeP: number;
+};
+export type PairAccumulatedFees = {
+    accPerOiLong: number;
+    accPerOiShort: number;
+    lastUpdateBlock: number;
+};
+export type TradeInitialAccFees = {
+    accPerOiLong: number;
+    accPerOiShort: number;
+    openBlock: number;
+};
+export type PairOiAfterV10 = {
+    oiLongToken: number;
+    oiShortToken: number;
+};
+export type FundingRateCalculation = {
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    currentVelocityPerYear: number;
+    avgFundingRatePerSecondP: number;
+    currentFundingRatePerSecondP: number;
+    secondsSinceLastUpdate: number;
+    longAprMultiplier: number;
+    shortAprMultiplier: number;
+};
+export type GetFundingFeeContext = {
+    currentTimestamp: number;
+    fundingParams: {
+        [collateralIndex: number]: {
+            [pairIndex: number]: FundingFeeParams;
+        };
+    };
+    fundingData: {
+        [collateralIndex: number]: {
+            [pairIndex: number]: PairFundingFeeData;
+        };
+    };
+    globalParams?: {
+        [collateralIndex: number]: {
+            [pairIndex: number]: PairGlobalParams;
+        };
+    };
+};
+export type TradeFundingFeeResult = {
+    fundingFeeCollateral: number;
+    fundingFeeP: number;
+    currentAccFundingFeeP: number;
+    initialAccFundingFeeP: number;
+};
+export type PairPendingAccFundingFeesResult = {
+    accFundingFeeLongP: number;
+    accFundingFeeShortP: number;
+    currentFundingRatePerSecondP: number;
+};

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Funding fees types for v10+ trades
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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,4 +1,10 @@
-import { Fee, PairIndex } from "../types";
-export declare const getClosingFee: (posDai: number, leverage: number, pairIndex: PairIndex, pairFee: Fee | undefined, collateralPriceUsd?: number | undefined, feeMultiplier?: number | undefined) => number;
 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";
+export { fetchBorrowingFeeParamsV2, fetchPairBorrowingFeeDataV2, fetchTradeBorrowingFeesCollateralV2, fetchPairPendingAccBorrowingFeesV2, fetchAllBorrowingV2Data, createBorrowingV2ContextFromContract, createBorrowingV2ContextFromArrays, fetchBorrowingV2DataForPairs, } from "./borrowingV2/fetcher";
+export { FundingFees, getCurrentFundingVelocityPerYear, getSecondsToReachZeroRate, getAvgFundingRatePerSecondP, getLongShortAprMultiplier, getPairPendingAccFundingFees, getTradeFundingFeesCollateral, getTradeFundingFeesCollateralSimple, getTradeFundingFees, } from "./fundingFees";
+export { convertFundingFeeParams, convertFundingFeeParamsArray, convertPairFundingFeeData, convertPairFundingFeeDataArray, convertPairGlobalParams, convertPairGlobalParamsArray, convertTradeInitialAccFundingFees, createFundingFeeContext, isValidFundingRate, fundingRateToAPR, aprToFundingRate, calculateVelocityFromSkew, FUNDING_FEES_PRECISION, } from "./fundingFees/converter";