@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc1

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

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * @dev Converters for funding fees data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetFundingFeeContext = exports.calculateVelocityFromSkew = exports.aprToFundingRate = exports.fundingRateToAPR = exports.isValidFundingRate = exports.createFundingFeeContext = exports.convertTradeInitialAccFundingFees = exports.convertPairGlobalParamsArray = exports.convertPairGlobalParams = exports.convertPairFundingFeeDataArray = exports.convertPairFundingFeeData = exports.convertFundingFeeParamsArray = exports.convertFundingFeeParams = exports.FUNDING_FEES_PRECISION = void 0;
+// Precision constants from contract
+exports.FUNDING_FEES_PRECISION = {
+    SKEW_COEFFICIENT_PER_YEAR: 1e26,
+    ABSOLUTE_VELOCITY_PER_YEAR_CAP: 1e7,
+    ABSOLUTE_RATE_PER_SECOND_CAP: 1e10,
+    ACC_FUNDING_FEE_P: 1e20,
+    FUNDING_RATE_PER_SECOND_P: 1e18, // Funding rate per second precision
+};
+/**
+ * @dev Converts contract funding fee params to SDK format
+ * @param contractParams Contract funding fee params struct
+ * @returns Normalized funding fee params
+ */
+const convertFundingFeeParams = (contractParams) => {
+    return {
+        skewCoefficientPerYear: Number(contractParams.skewCoefficientPerYear) /
+            exports.FUNDING_FEES_PRECISION.SKEW_COEFFICIENT_PER_YEAR,
+        absoluteVelocityPerYearCap: Number(contractParams.absoluteVelocityPerYearCap) /
+            exports.FUNDING_FEES_PRECISION.ABSOLUTE_VELOCITY_PER_YEAR_CAP,
+        absoluteRatePerSecondCap: Number(contractParams.absoluteRatePerSecondCap) /
+            exports.FUNDING_FEES_PRECISION.ABSOLUTE_RATE_PER_SECOND_CAP,
+        thetaThresholdUsd: Number(contractParams.thetaThresholdUsd),
+        fundingFeesEnabled: Boolean(contractParams.fundingFeesEnabled),
+        aprMultiplierEnabled: Boolean(contractParams.aprMultiplierEnabled),
+    };
+};
+exports.convertFundingFeeParams = convertFundingFeeParams;
+/**
+ * @dev Converts array of contract funding fee params to SDK format
+ * @param contractParamsArray Array of contract funding fee params
+ * @returns Array of normalized funding fee params
+ */
+const convertFundingFeeParamsArray = (contractParamsArray) => {
+    return contractParamsArray.map(exports.convertFundingFeeParams);
+};
+exports.convertFundingFeeParamsArray = convertFundingFeeParamsArray;
+/**
+ * @dev Converts contract pair funding fee data to SDK format
+ * @param contractData Contract pair funding fee data struct
+ * @returns Normalized pair funding fee data
+ */
+const convertPairFundingFeeData = (contractData) => {
+    return {
+        accFundingFeeLongP: Number(contractData.accFundingFeeLongP) /
+            exports.FUNDING_FEES_PRECISION.ACC_FUNDING_FEE_P,
+        accFundingFeeShortP: Number(contractData.accFundingFeeShortP) /
+            exports.FUNDING_FEES_PRECISION.ACC_FUNDING_FEE_P,
+        lastFundingRatePerSecondP: Number(contractData.lastFundingRatePerSecondP) /
+            exports.FUNDING_FEES_PRECISION.FUNDING_RATE_PER_SECOND_P,
+        lastFundingUpdateTs: Number(contractData.lastFundingUpdateTs),
+    };
+};
+exports.convertPairFundingFeeData = convertPairFundingFeeData;
+/**
+ * @dev Converts array of contract pair funding fee data to SDK format
+ * @param contractDataArray Array of contract pair funding fee data
+ * @returns Array of normalized pair funding fee data
+ */
+const convertPairFundingFeeDataArray = (contractDataArray) => {
+    return contractDataArray.map(exports.convertPairFundingFeeData);
+};
+exports.convertPairFundingFeeDataArray = convertPairFundingFeeDataArray;
+/**
+ * @dev Converts contract pair global params to SDK format
+ * @param contractParams Contract pair global params struct
+ * @returns Normalized pair global params
+ */
+const convertPairGlobalParams = (contractParams) => {
+    return {
+        maxSkewCollateral: Number(contractParams.maxSkewCollateral),
+    };
+};
+exports.convertPairGlobalParams = convertPairGlobalParams;
+/**
+ * @dev Converts array of contract pair global params to SDK format
+ * @param contractParamsArray Array of contract pair global params
+ * @returns Array of normalized pair global params
+ */
+const convertPairGlobalParamsArray = (contractParamsArray) => {
+    return contractParamsArray.map(exports.convertPairGlobalParams);
+};
+exports.convertPairGlobalParamsArray = convertPairGlobalParamsArray;
+/**
+ * @dev Converts contract trade initial acc funding fees to SDK format
+ * @param contractFees Contract trade fees data (only funding fee part)
+ * @returns Normalized trade initial acc funding fees
+ */
+const convertTradeInitialAccFundingFees = (contractFees) => {
+    return {
+        initialAccFundingFeeP: Number(contractFees.initialAccFundingFeeP) /
+            exports.FUNDING_FEES_PRECISION.ACC_FUNDING_FEE_P,
+    };
+};
+exports.convertTradeInitialAccFundingFees = convertTradeInitialAccFundingFees;
+/**
+ * @dev Creates a funding fee context from arrays of data
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of funding fee parameters
+ * @param data Array of pair funding fee data
+ * @param globalParams Optional array of global parameters
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete funding fee context
+ */
+const createFundingFeeContext = (collateralIndices, pairIndices, params, data, globalParams, currentTimestamp) => {
+    const context = {
+        currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000),
+        fundingParams: {},
+        fundingData: {},
+        globalParams: globalParams ? {} : undefined,
+    };
+    // Build nested objects indexed by collateralIndex and pairIndex
+    for (let i = 0; i < collateralIndices.length; i++) {
+        const collateralIndex = collateralIndices[i];
+        const pairIndex = pairIndices[i];
+        // Initialize collateral index objects if they don't exist
+        if (!context.fundingParams[collateralIndex]) {
+            context.fundingParams[collateralIndex] = {};
+        }
+        if (!context.fundingData[collateralIndex]) {
+            context.fundingData[collateralIndex] = {};
+        }
+        if (globalParams && context.globalParams) {
+            if (!context.globalParams[collateralIndex]) {
+                context.globalParams[collateralIndex] = {};
+            }
+        }
+        // Store data
+        context.fundingParams[collateralIndex][pairIndex] = params[i];
+        context.fundingData[collateralIndex][pairIndex] = data[i];
+        if (globalParams && context.globalParams) {
+            context.globalParams[collateralIndex][pairIndex] = globalParams[i];
+        }
+    }
+    return context;
+};
+exports.createFundingFeeContext = createFundingFeeContext;
+/**
+ * @dev Validates funding rate is within allowed bounds
+ * @param absoluteRatePerSecondCap Rate cap (normalized)
+ * @returns Whether the rate is valid
+ */
+const isValidFundingRate = (absoluteRatePerSecondCap) => {
+    // Convert back to contract precision for validation
+    const contractValue = absoluteRatePerSecondCap *
+        exports.FUNDING_FEES_PRECISION.ABSOLUTE_RATE_PER_SECOND_CAP;
+    return contractValue <= 3170979; // MAX_FUNDING_RATE_PER_SECOND from contract
+};
+exports.isValidFundingRate = isValidFundingRate;
+/**
+ * @dev Converts funding rate per second to APR
+ * @param ratePerSecondP Funding rate per second (normalized)
+ * @returns APR as percentage
+ */
+const fundingRateToAPR = (ratePerSecondP) => {
+    return ratePerSecondP * 365 * 24 * 60 * 60 * 100;
+};
+exports.fundingRateToAPR = fundingRateToAPR;
+/**
+ * @dev Converts APR to funding rate per second
+ * @param apr APR as percentage
+ * @returns Funding rate per second (normalized)
+ */
+const aprToFundingRate = (apr) => {
+    return apr / (365 * 24 * 60 * 60 * 100);
+};
+exports.aprToFundingRate = aprToFundingRate;
+/**
+ * @dev Calculates velocity per year from skew coefficient
+ * @param skewRatio Current skew ratio (net exposure / total OI)
+ * @param skewCoefficientPerYear Skew coefficient per year (normalized)
+ * @returns Velocity per year
+ */
+const calculateVelocityFromSkew = (skewRatio, skewCoefficientPerYear) => {
+    return Math.abs(skewRatio) * skewCoefficientPerYear;
+};
+exports.calculateVelocityFromSkew = calculateVelocityFromSkew;
+/**
+ * @dev Creates a GetFundingFeeContext from arrays (alias for consistency)
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of funding fee parameters
+ * @param data Array of pair funding fee data
+ * @returns Complete funding fee context
+ */
+const createGetFundingFeeContext = (collateralIndices, pairIndices, params, data) => {
+    return (0, exports.createFundingFeeContext)(collateralIndices, pairIndices, params, data);
+};
+exports.createGetFundingFeeContext = createGetFundingFeeContext;

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

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

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

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collateralToContractFormat = exports.priceToContractFormat = exports.fetchPairPendingAccFundingFeesBatch = exports.fetchTradeFeesDataBatch = exports.fetchTradeFeesData = exports.fetchTradeFundingFeesCollateral = exports.fetchPairPendingAccFundingFees = void 0;
+/**
+ * @dev Fetches pending accumulated funding fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param currentPairPrice Current pair price (1e10)
+ * @returns Promise resolving to accumulated funding fees and current rate
+ */
+const fetchPairPendingAccFundingFees = (contract, collateralIndex, pairIndex, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const result = yield contract.getPairPendingAccFundingFees(collateralIndex, pairIndex, currentPairPrice);
+        return {
+            accFundingFeeLongP: Number(result.accFundingFeeLongP) / 1e20,
+            accFundingFeeShortP: Number(result.accFundingFeeShortP) / 1e20,
+            currentFundingRatePerSecondP: Number(result.currentFundingRatePerSecondP) / 1e18, // FUNDING_RATE_PER_SECOND_P precision
+        };
+    }
+    catch (error) {
+        console.error("Error fetching pair pending acc funding fees:", error);
+        throw error;
+    }
+});
+exports.fetchPairPendingAccFundingFees = fetchPairPendingAccFundingFees;
+/**
+ * @dev Fetches funding fees for a specific trade in collateral tokens
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Trader address
+ * @param index Trade index
+ * @param currentPairPrice Current pair price (1e10)
+ * @returns Promise resolving to funding fee in collateral tokens
+ */
+const fetchTradeFundingFeesCollateral = (contract, trader, index, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const fundingFeeCollateral = yield contract.getTradeFundingFeesCollateral(trader, index, currentPairPrice);
+        // Convert from BigNumber to number (collateral precision already applied)
+        return Number(fundingFeeCollateral);
+    }
+    catch (error) {
+        console.error("Error fetching trade funding fees:", error);
+        throw error;
+    }
+});
+exports.fetchTradeFundingFeesCollateral = fetchTradeFundingFeesCollateral;
+/**
+ * @dev Fetches trade fees data for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Trader address
+ * @param index Trade index
+ * @returns Promise resolving to trade fees data
+ */
+const fetchTradeFeesData = (contract, trader, index) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const feesData = yield contract.getTradeFeesData(trader, index);
+        return {
+            accPerOiLong: Number(feesData.initialAccFundingFeeP) / 1e20,
+            accPerOiShort: Number(feesData.initialAccFundingFeeP) / 1e20,
+            openBlock: 0, // Not available in this struct
+        };
+    }
+    catch (error) {
+        console.error("Error fetching trade fees data:", error);
+        throw error;
+    }
+});
+exports.fetchTradeFeesData = fetchTradeFeesData;
+/**
+ * @dev Fetches trade fees data for multiple trades
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param traders Array of trader addresses
+ * @param indices Array of trade indices
+ * @returns Promise resolving to array of trade fees data
+ */
+const fetchTradeFeesDataBatch = (contract, traders, indices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (traders.length !== indices.length) {
+        throw new Error("Traders and indices arrays must have the same length");
+    }
+    try {
+        const feesDatas = yield contract.getTradeFeesDataArray(traders, indices);
+        return feesDatas.map(feesData => ({
+            accPerOiLong: Number(feesData.initialAccFundingFeeP) / 1e20,
+            accPerOiShort: Number(feesData.initialAccFundingFeeP) / 1e20,
+            openBlock: 0,
+        }));
+    }
+    catch (error) {
+        console.error("Error fetching trade fees data batch:", error);
+        throw error;
+    }
+});
+exports.fetchTradeFeesDataBatch = fetchTradeFeesDataBatch;
+/**
+ * @dev Fetches pending accumulated funding fees for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param currentPairPrices Array of current pair prices (1e10)
+ * @returns Promise resolving to array of accumulated funding fees
+ */
+const fetchPairPendingAccFundingFeesBatch = (contract, collateralIndices, pairIndices, currentPairPrices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length ||
+        pairIndices.length !== currentPairPrices.length) {
+        throw new Error("All input arrays must have the same length");
+    }
+    try {
+        // Fetch all in parallel
+        const promises = collateralIndices.map((collateralIndex, i) => contract.getPairPendingAccFundingFees(collateralIndex, pairIndices[i], currentPairPrices[i]));
+        const results = yield Promise.all(promises);
+        return results.map(result => ({
+            accFundingFeeLongP: Number(result.accFundingFeeLongP) / 1e20,
+            accFundingFeeShortP: Number(result.accFundingFeeShortP) / 1e20,
+            currentFundingRatePerSecondP: Number(result.currentFundingRatePerSecondP) / 1e18,
+        }));
+    }
+    catch (error) {
+        console.error("Error fetching pair pending acc funding fees batch:", error);
+        throw error;
+    }
+});
+exports.fetchPairPendingAccFundingFeesBatch = fetchPairPendingAccFundingFeesBatch;
+/**
+ * @dev Helper to convert price from number to contract format
+ * @param price Price as number
+ * @returns Price in contract format (1e10)
+ */
+const priceToContractFormat = (price) => {
+    return BigInt(Math.round(price * 1e10));
+};
+exports.priceToContractFormat = priceToContractFormat;
+/**
+ * @dev Helper to convert collateral amount to contract format
+ * @param amount Amount as number
+ * @param decimals Collateral decimals (6 for USDC, 18 for others)
+ * @returns Amount in contract format
+ */
+const collateralToContractFormat = (amount, decimals) => {
+    return BigInt(Math.round(amount * Math.pow(10, decimals)));
+};
+exports.collateralToContractFormat = collateralToContractFormat;

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

@@ -0,0 +1,124 @@
+/**
+ * @dev Funding fees calculations for v10+ trades
+ * @dev Based on skew-based funding rate model with velocity and APR multipliers
+ */
+import { FundingFeeParams, PairFundingFeeData, GetFundingFeeContext, TradeFundingFeeResult, PairPendingAccFundingFeesResult, PairOiAfterV10 } from "./types";
+import { GetPairFundingFeeContext } from "./pairContext";
+/**
+ * @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
+ */
+export declare const getCurrentFundingVelocityPerYear: (netExposureToken: number, netExposureUsd: number, skewCoefficientPerYear: number, absoluteVelocityPerYearCap: number, thetaThresholdUsd: number) => number;
+/**
+ * @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
+ */
+export declare const getSecondsToReachZeroRate: (lastFundingRatePerSecondP: number, currentVelocityPerYear: number) => number;
+/**
+ * @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
+ */
+export declare const getAvgFundingRatePerSecondP: (lastFundingRatePerSecondP: number, absoluteRatePerSecondCap: number, currentVelocityPerYear: number, secondsSinceLastUpdate: number) => {
+    avgFundingRatePerSecondP: number;
+    currentFundingRatePerSecondP: number;
+};
+/**
+ * @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
+ */
+export declare const getLongShortAprMultiplier: (avgFundingRatePerSecondP: number, pairOiLongToken: number, pairOiShortToken: number, aprMultiplierEnabled: boolean) => {
+    longAprMultiplier: number;
+    shortAprMultiplier: number;
+};
+/**
+ * @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
+ */
+export declare const getPairPendingAccFundingFees: (params: FundingFeeParams, data: PairFundingFeeData, currentPairPrice: number, pairOiToken: PairOiAfterV10, netExposureToken: number, netExposureUsd: number, currentTimestamp: number) => PairPendingAccFundingFeesResult;
+/**
+ * @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
+ */
+export declare const getTradeFundingFeesCollateral: (trade: {
+    collateralAmount: number;
+    leverage: number;
+    openPrice: number;
+    long: boolean;
+}, tradeInfo: {
+    contractsVersion: number;
+}, tradeFeesData: {
+    initialAccFundingFeeP: number;
+}, currentPairPrice: number, context: GetPairFundingFeeContext) => number;
+/**
+ * @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
+ */
+export declare const getTradeFundingFees: (input: {
+    collateralIndex: number;
+    pairIndex: number;
+    trade: {
+        collateralAmount: number;
+        leverage: number;
+        openPrice: number;
+        long: boolean;
+    };
+    tradeInfo: {
+        contractsVersion: number;
+    };
+    initialAccFundingFeeP: number;
+    currentPairPrice: number;
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+}, context: GetFundingFeeContext) => TradeFundingFeeResult;
+/**
+ * @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
+ */
+export declare const getTradeFundingFeesCollateralSimple: (trade: {
+    collateralAmount: number;
+    leverage: number;
+    openPrice: number;
+    long: boolean;
+}, tradeInfo: {
+    contractsVersion: number;
+}, initialAccFundingFeeP: number, currentAccFundingFeeP: number) => number;
+export * as FundingFees from "./types";
+export type { FundingFeeParams, PairFundingFeeData, PairGlobalParams, TradeInitialAccFundingFees, PairOiAfterV10, FundingRateCalculation, GetFundingFeeContext, TradeFundingFeeResult, PairPendingAccFundingFeesResult, PairAccumulatedFees, TradeInitialAccFees, } from "./types";
+export type { GetPairFundingFeeContext } from "./pairContext";
+export * from "./fetcher";
+export * from "./pairContext";
+export * from "./builder";