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

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

@@ -0,0 +1,140 @@
+"use strict";
+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.BorrowingFeeV2 = exports.borrowingFeeV2Utils = exports.getPairBorrowingFees = exports.getBorrowingFee = exports.getTradeBorrowingFeesCollateral = exports.getPairPendingAccBorrowingFees = exports.BORROWING_V2_PRECISION = exports.MAX_BORROWING_RATE_PER_SECOND = void 0;
+/**
+ * @dev Maximum borrowing rate per second (1,000% APR)
+ */
+exports.MAX_BORROWING_RATE_PER_SECOND = 0.0317097; // 317097 / 1e10
+/**
+ * @dev Precision constants for borrowing v2 calculations
+ */
+exports.BORROWING_V2_PRECISION = {
+    RATE_PER_SECOND: 1e10,
+    ACC_FEE: 1e20,
+    PERCENTAGE: 100,
+};
+/**
+ * @dev Calculates pending accumulated borrowing fees for a pair
+ * @param params Borrowing fee parameters for the pair
+ * @param data Current borrowing fee data for the pair
+ * @param currentPairPrice Current price of the trading pair
+ * @param currentTimestamp Current timestamp (defaults to now)
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+const getPairPendingAccBorrowingFees = (params, data, currentPairPrice, currentTimestamp) => {
+    const timestamp = currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000);
+    // Calculate time elapsed since last update
+    const timeElapsed = Math.max(0, timestamp - data.lastBorrowingUpdateTs);
+    // If no time elapsed, return current accumulated fee
+    if (timeElapsed === 0) {
+        return data.accBorrowingFeeP;
+    }
+    // Calculate accumulated borrowing fee delta
+    // Formula: borrowingRatePerSecondP * timeElapsed * currentPairPrice
+    const accBorrowingFeeDeltaP = params.borrowingRatePerSecondP * timeElapsed * currentPairPrice;
+    return data.accBorrowingFeeP + accBorrowingFeeDeltaP;
+};
+exports.getPairPendingAccBorrowingFees = getPairPendingAccBorrowingFees;
+/**
+ * @dev Calculates borrowing fees owed by a specific trade
+ * @param input Trade borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+const getTradeBorrowingFeesCollateral = (input, context) => {
+    var _a, _b;
+    const { positionSizeCollateral, openPrice, collateralIndex, pairIndex, currentPairPrice, initialAccBorrowingFeeP, currentTimestamp, } = input;
+    // Get borrowing parameters and data for the pair
+    const params = (_a = context.borrowingParams[collateralIndex]) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const data = (_b = context.borrowingData[collateralIndex]) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    if (!params || !data) {
+        return 0;
+    }
+    // Calculate current accumulated borrowing fees
+    const currentAccBorrowingFeeP = (0, exports.getPairPendingAccBorrowingFees)(params, data, currentPairPrice, currentTimestamp);
+    // Calculate borrowing fees for this trade
+    // Formula: (positionSizeCollateral * (currentAccFee - initialAccFee)) / openPrice / 100
+    const feeDeltaP = currentAccBorrowingFeeP - initialAccBorrowingFeeP;
+    return ((positionSizeCollateral * feeDeltaP) /
+        openPrice /
+        exports.BORROWING_V2_PRECISION.PERCENTAGE);
+};
+exports.getTradeBorrowingFeesCollateral = getTradeBorrowingFeesCollateral;
+/**
+ * @dev Convenience function to calculate borrowing fees for a trade using individual parameters
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param pairIndex Index of the trading pair
+ * @param collateralIndex Index of the collateral
+ * @param openPrice Price at which the trade was opened
+ * @param currentPairPrice Current price of the trading pair
+ * @param initialAccBorrowingFeeP Initial accumulated borrowing fee when trade was opened
+ * @param context Context containing borrowing parameters and data
+ * @returns Borrowing fees in collateral tokens
+ */
+const getBorrowingFee = (positionSizeCollateral, pairIndex, collateralIndex, openPrice, currentPairPrice, initialAccBorrowingFeeP, context) => {
+    return (0, exports.getTradeBorrowingFeesCollateral)({
+        positionSizeCollateral,
+        openPrice,
+        collateralIndex,
+        pairIndex,
+        currentPairPrice,
+        initialAccBorrowingFeeP,
+        currentTimestamp: context.currentTimestamp,
+    }, context);
+};
+exports.getBorrowingFee = getBorrowingFee;
+/**
+ * @dev Utility function to get pending accumulated borrowing fees for a pair using context
+ * @param input Pair borrowing fee calculation input
+ * @param context Context containing borrowing parameters and data
+ * @returns Updated accumulated borrowing fee (1e20 precision)
+ */
+const getPairBorrowingFees = (input, context) => {
+    var _a, _b;
+    const { collateralIndex, pairIndex, currentPairPrice, currentTimestamp } = input;
+    const params = (_a = context.borrowingParams[collateralIndex]) === null || _a === void 0 ? void 0 : _a[pairIndex];
+    const data = (_b = context.borrowingData[collateralIndex]) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    if (!params || !data) {
+        return 0;
+    }
+    return (0, exports.getPairPendingAccBorrowingFees)(params, data, currentPairPrice, currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : context.currentTimestamp);
+};
+exports.getPairBorrowingFees = getPairBorrowingFees;
+/**
+ * @dev Utility functions for working with borrowing v2 fees
+ */
+exports.borrowingFeeV2Utils = {
+    getPairPendingAccBorrowingFees: exports.getPairPendingAccBorrowingFees,
+    getTradeBorrowingFeesCollateral: exports.getTradeBorrowingFeesCollateral,
+    getPairBorrowingFees: exports.getPairBorrowingFees,
+    getBorrowingFee: exports.getBorrowingFee,
+};
+exports.BorrowingFeeV2 = __importStar(require("./types"));
+__exportStar(require("./converter"), exports);
+__exportStar(require("./fetcher"), exports);

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

@@ -0,0 +1,79 @@
+/**
+ * @dev Types for borrowing v2 fees system (simplified rate-based model)
+ */
+/**
+ * @dev Borrowing fee parameters for a specific pair/collateral combination
+ */
+export type BorrowingFeeParams = {
+    /**
+     * @dev Borrowing rate % per second
+     * @dev Raw contract value divided by 1e10
+     * @dev Max: ~0.0000317097 => 1,000% APR
+     */
+    borrowingRatePerSecondP: number;
+};
+/**
+ * @dev Accumulated borrowing fee data for a specific pair/collateral combination
+ */
+export type PairBorrowingFeeData = {
+    /**
+     * @dev Accumulated borrowing fees % weighted by pair price
+     * @dev Unit: fee collateral per 100 units of OI in pair amount
+     */
+    accBorrowingFeeP: number;
+    /**
+     * @dev Timestamp of last accumulated borrowing fees update
+     */
+    lastBorrowingUpdateTs: number;
+};
+/**
+ * @dev Trade-specific borrowing fee data stored when position is opened
+ */
+export type TradeInitialAccFees = {
+    /**
+     * @dev Initial accumulated borrowing fee when trade was opened (normalized float)
+     * @dev Raw contract value divided by 1e20
+     * @dev Used to calculate how much borrowing fees the trade owes
+     */
+    initialAccBorrowingFeeP: number;
+};
+/**
+ * @dev Context required for borrowing v2 fee calculations
+ */
+export type GetBorrowingFeeV2Context = {
+    /**
+     * @dev Current timestamp (defaults to Date.now() / 1000)
+     */
+    currentTimestamp?: number;
+    /**
+     * @dev Borrowing fee parameters for pairs
+     * @dev Indexed by: params[collateralIndex][pairIndex]
+     */
+    borrowingParams: Record<number, Record<number, BorrowingFeeParams>>;
+    /**
+     * @dev Borrowing fee data for pairs
+     * @dev Indexed by: data[collateralIndex][pairIndex]
+     */
+    borrowingData: Record<number, Record<number, PairBorrowingFeeData>>;
+};
+/**
+ * @dev Input for calculating pending borrowing fees for a pair
+ */
+export type PairBorrowingFeeInput = {
+    collateralIndex: number;
+    pairIndex: number;
+    currentPairPrice: number;
+    currentTimestamp?: number;
+};
+/**
+ * @dev Input for calculating borrowing fees for a specific trade
+ */
+export type TradeBorrowingFeeInput = {
+    positionSizeCollateral: number;
+    openPrice: number;
+    collateralIndex: number;
+    pairIndex: number;
+    currentPairPrice: number;
+    initialAccBorrowingFeeP: number;
+    currentTimestamp?: number;
+};

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Types for borrowing v2 fees system (simplified rate-based model)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/trade/fees/converter.js

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

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

@@ -0,0 +1,102 @@
+/**
+ * @dev Converters for funding fees data between contract and SDK formats
+ * @dev All BigNumber values are normalized to floats with appropriate precision
+ */
+import { IFundingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { FundingFeeParams, PairFundingFeeData, PairGlobalParams, TradeInitialAccFundingFees, GetFundingFeeContext } from "./types";
+export declare const FUNDING_FEES_PRECISION: {
+    SKEW_COEFFICIENT_PER_YEAR: number;
+    ABSOLUTE_VELOCITY_PER_YEAR_CAP: number;
+    ABSOLUTE_RATE_PER_SECOND_CAP: number;
+    ACC_FUNDING_FEE_P: number;
+    FUNDING_RATE_PER_SECOND_P: number;
+};
+/**
+ * @dev Converts contract funding fee params to SDK format
+ * @param contractParams Contract funding fee params struct
+ * @returns Normalized funding fee params
+ */
+export declare const convertFundingFeeParams: (contractParams: IFundingFees.FundingFeeParamsStruct) => FundingFeeParams;
+/**
+ * @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
+ */
+export declare const convertFundingFeeParamsArray: (contractParamsArray: IFundingFees.FundingFeeParamsStruct[]) => FundingFeeParams[];
+/**
+ * @dev Converts contract pair funding fee data to SDK format
+ * @param contractData Contract pair funding fee data struct
+ * @returns Normalized pair funding fee data
+ */
+export declare const convertPairFundingFeeData: (contractData: IFundingFees.PairFundingFeeDataStruct) => PairFundingFeeData;
+/**
+ * @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
+ */
+export declare const convertPairFundingFeeDataArray: (contractDataArray: IFundingFees.PairFundingFeeDataStruct[]) => PairFundingFeeData[];
+/**
+ * @dev Converts contract pair global params to SDK format
+ * @param contractParams Contract pair global params struct
+ * @returns Normalized pair global params
+ */
+export declare const convertPairGlobalParams: (contractParams: IFundingFees.PairGlobalParamsStruct) => PairGlobalParams;
+/**
+ * @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
+ */
+export declare const convertPairGlobalParamsArray: (contractParamsArray: IFundingFees.PairGlobalParamsStruct[]) => PairGlobalParams[];
+/**
+ * @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
+ */
+export declare const convertTradeInitialAccFundingFees: (contractFees: {
+    initialAccFundingFeeP: bigint | number | string;
+}) => TradeInitialAccFundingFees;
+/**
+ * @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
+ */
+export declare const createFundingFeeContext: (collateralIndices: number[], pairIndices: number[], params: FundingFeeParams[], data: PairFundingFeeData[], globalParams?: PairGlobalParams[], currentTimestamp?: number) => GetFundingFeeContext;
+/**
+ * @dev Validates funding rate is within allowed bounds
+ * @param absoluteRatePerSecondCap Rate cap (normalized)
+ * @returns Whether the rate is valid
+ */
+export declare const isValidFundingRate: (absoluteRatePerSecondCap: number) => boolean;
+/**
+ * @dev Converts funding rate per second to APR
+ * @param ratePerSecondP Funding rate per second (normalized)
+ * @returns APR as percentage
+ */
+export declare const fundingRateToAPR: (ratePerSecondP: number) => number;
+/**
+ * @dev Converts APR to funding rate per second
+ * @param apr APR as percentage
+ * @returns Funding rate per second (normalized)
+ */
+export declare const aprToFundingRate: (apr: number) => number;
+/**
+ * @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
+ */
+export declare const calculateVelocityFromSkew: (skewRatio: number, skewCoefficientPerYear: number) => number;
+/**
+ * @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
+ */
+export declare const createGetFundingFeeContext: (collateralIndices: number[], pairIndices: number[], params: FundingFeeParams[], data: PairFundingFeeData[]) => GetFundingFeeContext;