@gainsnetwork/sdk 0.2.67-rc7 → 0.2.67-rc8

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/tiers/converter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @dev Converters for fee tier data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+import { IFeeTiers } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { FeeTier, TraderInfo, TraderEnrollment } from "./types";
+/**
+ * @dev Converts contract fee tier data to SDK format
+ * @param contractData Contract FeeTier struct
+ * @returns Normalized fee tier data
+ */
+export declare const convertFeeTier: (contractData: IFeeTiers.FeeTierStructOutput) => FeeTier;
+/**
+ * @dev Converts array of fee tiers from contract format
+ * @param contractDataArray Array of contract FeeTier structs
+ * @returns Array of normalized fee tiers
+ */
+export declare const convertFeeTierArray: (contractDataArray: IFeeTiers.FeeTierStructOutput[]) => FeeTier[];
+/**
+ * @dev Converts contract trader info to SDK format
+ * @param contractData Contract TraderInfo struct
+ * @returns Normalized trader info
+ */
+export declare const convertTraderInfo: (contractData: IFeeTiers.TraderInfoStructOutput) => TraderInfo;
+/**
+ * @dev Converts contract trader enrollment to SDK format
+ * @param contractData Contract TraderEnrollment struct
+ * @returns Normalized trader enrollment
+ */
+export declare const convertTraderEnrollment: (contractData: IFeeTiers.TraderEnrollmentStructOutput) => TraderEnrollment;
+/**
+ * @dev Converts the complete fee tiers configuration from contract format
+ * @param tiers Array of fee tiers from contract
+ * @param groupVolumeMultipliers Array of group volume multipliers
+ * @param currentDay Current day from contract
+ * @returns Complete fee tiers configuration
+ */
+export declare const convertFeeTiersConfig: (tiers: IFeeTiers.FeeTierStructOutput[], groupVolumeMultipliers: readonly bigint[], currentDay: bigint) => {
+    tiers: FeeTier[];
+    groupVolumeMultipliers: number[];
+    currentDay: number;
+};
+/**
+ * @dev Converts trader's fee tier data from contract format
+ * @param traderInfo Trader info from contract
+ * @param traderDailyInfo Array of daily points info
+ * @param traderEnrollment Enrollment status from contract
+ * @returns Complete trader fee tier data
+ */
+export declare const convertTraderFeeTiersData: (traderInfo: IFeeTiers.TraderInfoStructOutput, traderDailyInfo: readonly bigint[], traderEnrollment: IFeeTiers.TraderEnrollmentStructOutput) => {
+    traderInfo: TraderInfo;
+    dailyPoints: number[];
+    traderEnrollment: TraderEnrollment;
+};

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

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * @dev Converters for fee tier data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTraderFeeTiersData = exports.convertFeeTiersConfig = exports.convertTraderEnrollment = exports.convertTraderInfo = exports.convertFeeTierArray = exports.convertFeeTier = void 0;
+/**
+ * @dev Converts contract fee tier data to SDK format
+ * @param contractData Contract FeeTier struct
+ * @returns Normalized fee tier data
+ */
+const convertFeeTier = (contractData) => {
+    return {
+        feeMultiplier: Number(contractData.feeMultiplier) / 1e3,
+        pointsThreshold: Number(contractData.pointsThreshold) / 1e18, // Points in 1e18 precision
+    };
+};
+exports.convertFeeTier = convertFeeTier;
+/**
+ * @dev Converts array of fee tiers from contract format
+ * @param contractDataArray Array of contract FeeTier structs
+ * @returns Array of normalized fee tiers
+ */
+const convertFeeTierArray = (contractDataArray) => {
+    return contractDataArray.map(exports.convertFeeTier);
+};
+exports.convertFeeTierArray = convertFeeTierArray;
+/**
+ * @dev Converts contract trader info to SDK format
+ * @param contractData Contract TraderInfo struct
+ * @returns Normalized trader info
+ */
+const convertTraderInfo = (contractData) => {
+    return {
+        lastDayUpdated: Number(contractData.lastDayUpdated),
+        trailingPoints: Number(contractData.trailingPoints) / 1e18, // Points in 1e18 precision
+    };
+};
+exports.convertTraderInfo = convertTraderInfo;
+/**
+ * @dev Converts contract trader enrollment to SDK format
+ * @param contractData Contract TraderEnrollment struct
+ * @returns Normalized trader enrollment
+ */
+const convertTraderEnrollment = (contractData) => {
+    return {
+        status: Number(contractData.status),
+    };
+};
+exports.convertTraderEnrollment = convertTraderEnrollment;
+/**
+ * @dev Converts the complete fee tiers configuration from contract format
+ * @param tiers Array of fee tiers from contract
+ * @param groupVolumeMultipliers Array of group volume multipliers
+ * @param currentDay Current day from contract
+ * @returns Complete fee tiers configuration
+ */
+const convertFeeTiersConfig = (tiers, groupVolumeMultipliers, currentDay) => {
+    return {
+        tiers: (0, exports.convertFeeTierArray)(tiers),
+        groupVolumeMultipliers: groupVolumeMultipliers.map(m => Number(m) / 1e3),
+        currentDay: Number(currentDay),
+    };
+};
+exports.convertFeeTiersConfig = convertFeeTiersConfig;
+/**
+ * @dev Converts trader's fee tier data from contract format
+ * @param traderInfo Trader info from contract
+ * @param traderDailyInfo Array of daily points info
+ * @param traderEnrollment Enrollment status from contract
+ * @returns Complete trader fee tier data
+ */
+const convertTraderFeeTiersData = (traderInfo, traderDailyInfo, traderEnrollment) => {
+    return {
+        traderInfo: (0, exports.convertTraderInfo)(traderInfo),
+        dailyPoints: traderDailyInfo.map(points => Number(points) / 1e18),
+        traderEnrollment: (0, exports.convertTraderEnrollment)(traderEnrollment),
+    };
+};
+exports.convertTraderFeeTiersData = convertTraderFeeTiersData;

package/lib/trade/fees/trading/builder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @dev Trading fees context builder module
+ * @dev Provides builder functions for creating trading fee contexts
+ */
+import { Fee, GlobalTradeFeeParams } from "../../types";
+import { GlobalTradingVariablesType } from "src/backend/tradingVariables/types";
+/**
+ * @dev Sub-context for trading fees
+ */
+export type TradingFeesSubContext = {
+    fee: Fee;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Builds trading fees sub-context
+ */
+export declare const buildTradingFeesContext: (globalTradingVariables: GlobalTradingVariablesType, pairIndex: number, traderFeeMultiplier?: number) => TradingFeesSubContext;

package/lib/trade/fees/trading/builder.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @dev Trading fees context builder module
+ * @dev Provides builder functions for creating trading fee contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTradingFeesContext = void 0;
+/**
+ * @dev Builds trading fees sub-context
+ */
+const buildTradingFeesContext = (globalTradingVariables, pairIndex, traderFeeMultiplier) => {
+    const { fees, pairs, globalTradeFeeParams } = globalTradingVariables;
+    const feeIndex = pairs[pairIndex].feeIndex;
+    return {
+        fee: fees[feeIndex],
+        globalTradeFeeParams: globalTradeFeeParams,
+        traderFeeMultiplier,
+    };
+};
+exports.buildTradingFeesContext = buildTradingFeesContext;

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

@@ -0,0 +1,30 @@
+/**
+ * @dev Converters for trading fee data between contract and SDK formats
+ */
+import { CounterTradeSettings } from "../../types";
+import { GlobalTradeFeeParams } from "./types";
+/**
+ * @dev Converts contract counter trade settings to SDK format
+ * @param feeRateMultiplier Fee rate multiplier from contract (1e3 precision)
+ * @param maxLeverage Max leverage from contract (1e3 precision)
+ * @returns Normalized counter trade settings
+ */
+export declare const convertCounterTradeSettings: (feeRateMultiplier: number, maxLeverage: number) => CounterTradeSettings;
+/**
+ * @dev Converts array of counter trade fee rate multipliers from contract
+ * @param multipliers Array of fee rate multipliers (1e3 precision)
+ * @returns Array of normalized multipliers
+ */
+export declare const convertCounterTradeFeeRateMultipliers: (multipliers: number[]) => number[];
+/**
+ * @dev Converts global trade fee params from contract to SDK format
+ * @param contractParams Global trade fee params from contract
+ * @returns Normalized global trade fee params
+ */
+export declare const convertGlobalTradeFeeParams: (contractParams: {
+    referralFeeP: number;
+    govFeeP: number;
+    triggerOrderFeeP: number;
+    gnsOtcFeeP: number;
+    gTokenFeeP: number;
+}) => GlobalTradeFeeParams;

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @dev Converters for trading fee data between contract and SDK formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGlobalTradeFeeParams = exports.convertCounterTradeFeeRateMultipliers = exports.convertCounterTradeSettings = void 0;
+/**
+ * @dev Converts contract counter trade settings to SDK format
+ * @param feeRateMultiplier Fee rate multiplier from contract (1e3 precision)
+ * @param maxLeverage Max leverage from contract (1e3 precision)
+ * @returns Normalized counter trade settings
+ */
+const convertCounterTradeSettings = (feeRateMultiplier, maxLeverage) => {
+    return {
+        feeRateMultiplier: feeRateMultiplier / 1000,
+        maxLeverage: maxLeverage / 1000, // 1e3 → float
+    };
+};
+exports.convertCounterTradeSettings = convertCounterTradeSettings;
+/**
+ * @dev Converts array of counter trade fee rate multipliers from contract
+ * @param multipliers Array of fee rate multipliers (1e3 precision)
+ * @returns Array of normalized multipliers
+ */
+const convertCounterTradeFeeRateMultipliers = (multipliers) => {
+    return multipliers.map(m => m / 1000);
+};
+exports.convertCounterTradeFeeRateMultipliers = convertCounterTradeFeeRateMultipliers;
+/**
+ * @dev Converts global trade fee params from contract to SDK format
+ * @param contractParams Global trade fee params from contract
+ * @returns Normalized global trade fee params
+ */
+const convertGlobalTradeFeeParams = (contractParams) => {
+    return {
+        referralFeeP: contractParams.referralFeeP / 1e10 / 100,
+        govFeeP: contractParams.govFeeP / 1e10 / 100,
+        triggerOrderFeeP: contractParams.triggerOrderFeeP / 1e10 / 100,
+        gnsOtcFeeP: contractParams.gnsOtcFeeP / 1e10 / 100,
+        gTokenFeeP: contractParams.gTokenFeeP / 1e10 / 100,
+    };
+};
+exports.convertGlobalTradeFeeParams = convertGlobalTradeFeeParams;

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

@@ -0,0 +1,62 @@
+/**
+ * @dev Trading fee calculations for opening and closing positions
+ */
+import { Fee, PairIndex, Trade, TradeInfo, TradeFeesData } from "../../types";
+import { GetBorrowingFeeContext } from "../borrowing";
+import * as BorrowingFee from "../borrowing/types";
+import { GetPairBorrowingFeeV2Context } from "../borrowingV2";
+import { GetPairFundingFeeContext } from "../fundingFees/pairContext";
+import { GetTradeFeesContext, GetLiquidationFeesContext, GetClosingFeeContext, TradeFeesBreakdown, TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+/**
+ * @dev Returns the total fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeFeesCollateral function
+ * @param collateralIndex Collateral index (not used in calculation, for consistency)
+ * @param trader Trader address (for fee tier lookup)
+ * @param pairIndex Index of the trading pair
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param isCounterTrade Whether the trade is a counter trade
+ * @param context Context containing fee parameters and settings
+ * @returns Total fee in collateral tokens
+ */
+export declare const getTotalTradeFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, positionSizeCollateral: number, isCounterTrade: boolean, context: GetTradeFeesContext) => number;
+/**
+ * @dev Returns the fee breakdown for a trade
+ * @dev Mirrors the contract's getTradeFeesCollateral function
+ */
+export declare const getTradeFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, positionSizeCollateral: number, isCounterTrade: boolean, context: GetTradeFeesContext) => TradeFeesBreakdown;
+/**
+ * @dev Returns total liquidation fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeLiqFeesCollateral function
+ */
+export declare const getTotalTradeLiqFeesCollateral: (collateralIndex: number, trader: string, pairIndex: PairIndex, collateralAmount: number, context: GetLiquidationFeesContext) => number;
+/**
+ * @dev Legacy function for backward compatibility
+ * @deprecated Use getTotalTradeFeesCollateral instead
+ */
+export declare const getClosingFee: (collateralAmount: number, leverage: number, pairIndex: PairIndex, pairFee: Fee | undefined, _collateralPriceUsd?: number | undefined, isCounterTrade?: boolean, trader?: string, context?: GetClosingFeeContext) => number;
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: GetBorrowingFeeContext;
+    borrowingV2?: GetPairBorrowingFeeV2Context;
+    funding?: GetPairFundingFeeContext;
+    initialAccFeesV1?: BorrowingFee.InitialAccFees;
+};
+/**
+ * @dev Calculates total holding fees for a trade (funding + borrowing fees)
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateral: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;
+export * from "./types";
+export * from "./converter";
+export * from "./builder";

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

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * @dev Trading fee calculations for opening and closing positions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateral = exports.getClosingFee = exports.getTotalTradeLiqFeesCollateral = exports.getTradeFeesCollateral = exports.getTotalTradeFeesCollateral = void 0;
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+const tiers_1 = require("../tiers");
+const types_1 = require("../../../contracts/types");
+/**
+ * @dev Returns the total fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeFeesCollateral function
+ * @param collateralIndex Collateral index (not used in calculation, for consistency)
+ * @param trader Trader address (for fee tier lookup)
+ * @param pairIndex Index of the trading pair
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param isCounterTrade Whether the trade is a counter trade
+ * @param context Context containing fee parameters and settings
+ * @returns Total fee in collateral tokens
+ */
+const getTotalTradeFeesCollateral = (collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context) => {
+    var _a;
+    const { fee, collateralPriceUsd } = context;
+    const { totalPositionSizeFeeP, minPositionSizeUsd } = fee;
+    // Get counter trade fee rate multiplier (default 1 = 1x)
+    const counterTradeFeeRateMultiplier = isCounterTrade && ((_a = context.counterTradeSettings) === null || _a === void 0 ? void 0 : _a[pairIndex])
+        ? context.counterTradeSettings[pairIndex].feeRateMultiplier
+        : 1;
+    // Apply counter trade multiplier to position size
+    const adjustedPositionSizeCollateral = positionSizeCollateral * counterTradeFeeRateMultiplier;
+    // Calculate minimum position size in collateral
+    const minPositionSizeCollateral = minPositionSizeUsd / collateralPriceUsd;
+    // Use max of adjusted position size and minimum position size
+    const positionSizeBasis = Math.max(adjustedPositionSizeCollateral, minPositionSizeCollateral);
+    // Calculate raw fee
+    const rawFee = totalPositionSizeFeeP * positionSizeBasis;
+    // Apply trader fee tier if available
+    return (0, tiers_1.calculateFeeAmount)(trader, rawFee, context.traderFeeMultiplier);
+};
+exports.getTotalTradeFeesCollateral = getTotalTradeFeesCollateral;
+/**
+ * @dev Returns the fee breakdown for a trade
+ * @dev Mirrors the contract's getTradeFeesCollateral function
+ */
+const getTradeFeesCollateral = (collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context) => {
+    const totalFees = (0, exports.getTotalTradeFeesCollateral)(collateralIndex, trader, pairIndex, positionSizeCollateral, isCounterTrade, context);
+    const { globalTradeFeeParams } = context;
+    const totalP = globalTradeFeeParams.referralFeeP +
+        globalTradeFeeParams.govFeeP +
+        globalTradeFeeParams.triggerOrderFeeP +
+        globalTradeFeeParams.gnsOtcFeeP +
+        globalTradeFeeParams.gTokenFeeP;
+    // Distribute fees proportionally
+    return {
+        referralFeeCollateral: (totalFees * globalTradeFeeParams.referralFeeP) / totalP,
+        govFeeCollateral: (totalFees * globalTradeFeeParams.govFeeP) / totalP,
+        triggerFeeCollateral: (totalFees * globalTradeFeeParams.triggerOrderFeeP) / totalP,
+        gnsOtcFeeCollateral: (totalFees * globalTradeFeeParams.gnsOtcFeeP) / totalP,
+        gTokenFeeCollateral: (totalFees * globalTradeFeeParams.gTokenFeeP) / totalP,
+    };
+};
+exports.getTradeFeesCollateral = getTradeFeesCollateral;
+/**
+ * @dev Returns total liquidation fee for a trade in collateral tokens
+ * @dev Mirrors the contract's getTotalTradeLiqFeesCollateral function
+ */
+const getTotalTradeLiqFeesCollateral = (collateralIndex, trader, pairIndex, collateralAmount, context) => {
+    const { totalLiqCollateralFeeP } = context;
+    // Calculate raw liquidation fee
+    const rawFee = collateralAmount * totalLiqCollateralFeeP;
+    // Apply trader fee tier if available
+    return (0, tiers_1.calculateFeeAmount)(trader, rawFee, context.traderFeeMultiplier);
+};
+exports.getTotalTradeLiqFeesCollateral = getTotalTradeLiqFeesCollateral;
+/**
+ * @dev Legacy function for backward compatibility
+ * @deprecated Use getTotalTradeFeesCollateral instead
+ */
+const getClosingFee = (collateralAmount, leverage, pairIndex, pairFee, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_collateralPriceUsd = 0, // Kept for backward compatibility
+isCounterTrade = false, trader, context) => {
+    if (!pairFee || !context)
+        return 0;
+    const positionSizeCollateral = collateralAmount * leverage;
+    return (0, exports.getTotalTradeFeesCollateral)(0, // collateralIndex not used
+    trader || "", pairIndex, positionSizeCollateral, isCounterTrade, context);
+};
+exports.getClosingFee = getClosingFee;
+/**
+ * @dev Calculates total holding fees for a trade (funding + borrowing fees)
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateral = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }));
+    }
+    // Calculate borrowing fees v2 (v10+ only)
+    let borrowingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.borrowingV2 &&
+        tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1 && context.initialAccFeesV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, trade.pairIndex, trade.long, context.initialAccFeesV1, context.borrowingV1);
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateral = getTradePendingHoldingFeesCollateral;
+// Export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);

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

@@ -0,0 +1,48 @@
+/**
+ * @dev Types for trading fee calculations (open/close position fees)
+ */
+import { Fee, CounterTradeSettings, GlobalTradeFeeParams } from "../../types";
+/**
+ * @dev Breakdown of trading fees into components
+ */
+export type TradeFeesBreakdown = {
+    referralFeeCollateral: number;
+    govFeeCollateral: number;
+    triggerFeeCollateral: number;
+    gnsOtcFeeCollateral: number;
+    gTokenFeeCollateral: number;
+};
+/**
+ * @dev Context for calculating trading fees
+ */
+export type GetTradeFeesContext = {
+    fee: Fee;
+    collateralPriceUsd: number;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    counterTradeSettings?: {
+        [pairIndex: number]: CounterTradeSettings;
+    };
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Context for calculating liquidation fees
+ */
+export type GetLiquidationFeesContext = {
+    totalLiqCollateralFeeP: number;
+    globalTradeFeeParams: GlobalTradeFeeParams;
+    traderFeeMultiplier?: number;
+};
+/**
+ * @dev Legacy support
+ */
+export type GetClosingFeeContext = GetTradeFeesContext;
+/**
+ * @dev Holding fees breakdown (funding + borrowing)
+ */
+export type TradeHoldingFees = {
+    fundingFeeCollateral: number;
+    borrowingFeeCollateral: number;
+    borrowingFeeCollateral_old: number;
+    totalFeeCollateral: number;
+};
+export type { GlobalTradeFeeParams };

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Types for trading fee calculations (open/close position fees)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/trade/liquidation/builder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @dev Liquidation price context builder module
+ * @dev Provides builder functions for creating liquidation price contexts
+ */
+import { GlobalTradingVariablesType } from "../../backend/tradingVariables/types";
+import { TradeContainer, UserPriceImpact } from "../types";
+import { GetLiquidationPriceContext } from "./types";
+/**
+ * @dev Builds a complete context for liquidation price calculations
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param tradeContainer Full trade container with trade, tradeInfo, fees data and liquidation params
+ * @param additionalParams Additional parameters not available in trading variables
+ * @returns Complete context ready for getLiquidationPrice
+ */
+export declare const buildLiquidationPriceContext: (globalTradingVariables: GlobalTradingVariablesType, tradeContainer: TradeContainer, additionalParams: {
+    currentBlock: number;
+    currentTimestamp: number;
+    currentPairPrice: number;
+    spreadP: number;
+    traderFeeMultiplier?: number;
+    additionalFeeCollateral?: number;
+    partialCloseMultiplier?: number;
+    beforeOpened?: boolean;
+    userPriceImpact?: UserPriceImpact;
+}) => GetLiquidationPriceContext;