@gainsnetwork/sdk 0.2.67-rc7 → 0.2.68

package/lib/contracts/fetch/priceImpact/skew.js

@@ -0,0 +1,168 @@
+"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.calculateTradeSkewPriceImpact = exports.fetchCollateralDecimals = exports.fetchSkewPriceImpactContext = exports.fetchPairSkewDepths = exports.fetchPairSkewDepth = exports.fetchPairOisAfterV10Token = exports.fetchPairOiAfterV10Token = void 0;
+const priceImpact_1 = require("../../../trade/priceImpact");
+/**
+ * @dev Fetches pair open interest in tokens for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @returns Promise resolving to pair OI in tokens
+ */
+const fetchPairOiAfterV10Token = (contract, collateralIndex, pairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const contractData = yield contract.getPairOiAfterV10Token(collateralIndex, pairIndex);
+        return (0, priceImpact_1.convertPairOiToken)(contractData);
+    }
+    catch (error) {
+        console.error("Error fetching pair OI token:", error);
+        throw error;
+    }
+});
+exports.fetchPairOiAfterV10Token = fetchPairOiAfterV10Token;
+/**
+ * @dev Fetches pair open interest in tokens for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of pair OI in tokens
+ */
+const fetchPairOisAfterV10Token = (contract, collateralIndices, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length) {
+        throw new Error("Collateral indices and pair indices arrays must have the same length");
+    }
+    try {
+        const contractDataArray = yield contract.getPairOisAfterV10Token(collateralIndices, pairIndices);
+        return contractDataArray.map(priceImpact_1.convertPairOiToken);
+    }
+    catch (error) {
+        console.error("Error fetching pair OIs token:", error);
+        throw error;
+    }
+});
+exports.fetchPairOisAfterV10Token = fetchPairOisAfterV10Token;
+/**
+ * @dev Fetches skew depth for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param collateralDecimals Number of decimals for the collateral
+ * @returns Promise resolving to normalized skew depth
+ */
+const fetchPairSkewDepth = (contract, collateralIndex, pairIndex, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const contractDepth = yield contract.getPairSkewDepth(collateralIndex, pairIndex);
+        return (0, priceImpact_1.normalizeSkewDepth)(contractDepth.toBigInt(), collateralDecimals);
+    }
+    catch (error) {
+        console.error("Error fetching skew depth:", error);
+        throw error;
+    }
+});
+exports.fetchPairSkewDepth = fetchPairSkewDepth;
+/**
+ * @dev Fetches skew depths for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to array of normalized skew depths
+ */
+const fetchPairSkewDepths = (contract, collateralIndices, pairIndices, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    if (collateralIndices.length !== pairIndices.length ||
+        pairIndices.length !== collateralDecimals.length) {
+        throw new Error("All input arrays must have the same length");
+    }
+    try {
+        const contractDepths = yield contract.getPairSkewDepths(collateralIndices, pairIndices);
+        return contractDepths.map((depth, i) => (0, priceImpact_1.normalizeSkewDepth)(depth.toBigInt(), collateralDecimals[i]));
+    }
+    catch (error) {
+        console.error("Error fetching skew depths:", error);
+        throw error;
+    }
+});
+exports.fetchPairSkewDepths = fetchPairSkewDepths;
+/**
+ * @dev Fetches complete skew price impact context for multiple pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param collateralDecimals Array of collateral decimals for each pair
+ * @returns Promise resolving to complete skew price impact context
+ */
+const fetchSkewPriceImpactContext = (contract, collateralIndices, pairIndices, collateralDecimals) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Fetch OI data and skew depths in parallel
+        const [pairOiTokens, skewDepths] = yield Promise.all([
+            (0, exports.fetchPairOisAfterV10Token)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairSkewDepths)(contract, collateralIndices, pairIndices, collateralDecimals),
+        ]);
+        return (0, priceImpact_1.createSkewPriceImpactContext)(collateralIndices, pairIndices, skewDepths, pairOiTokens);
+    }
+    catch (error) {
+        console.error("Error fetching skew price impact context:", error);
+        throw error;
+    }
+});
+exports.fetchSkewPriceImpactContext = fetchSkewPriceImpactContext;
+/**
+ * @dev Fetches collateral decimals for given collateral indices
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @returns Promise resolving to array of decimals
+ */
+const fetchCollateralDecimals = (contract, collateralIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // Get unique collateral indices to minimize calls
+        const uniqueIndices = [...new Set(collateralIndices)];
+        // Fetch collateral info for unique indices
+        const promises = uniqueIndices.map((index) => __awaiter(void 0, void 0, void 0, function* () {
+            const collateral = yield contract.getCollateral(index);
+            return { index, decimals: Number(collateral.precision) };
+        }));
+        const collateralData = yield Promise.all(promises);
+        // Create a map for quick lookup
+        const decimalsMap = new Map(collateralData.map(data => [data.index, data.decimals]));
+        // Return decimals in the same order as input
+        return collateralIndices.map(index => decimalsMap.get(index) || 18 // Default to 18 if not found
+        );
+    }
+    catch (error) {
+        console.error("Error fetching collateral decimals:", error);
+        throw error;
+    }
+});
+exports.fetchCollateralDecimals = fetchCollateralDecimals;
+/**
+ * @dev Calculates skew price impact for a trade using contract call
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Collateral index
+ * @param pairIndex Pair index
+ * @param long Whether trade is long
+ * @param positionSizeToken Position size in tokens
+ * @param open Whether trade is opening
+ * @returns Promise resolving to price impact percentage (1e10)
+ */
+const calculateTradeSkewPriceImpact = (contract, collateralIndex, pairIndex, long, positionSizeToken, open) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const priceImpactP = yield contract.getTradeSkewPriceImpactP(collateralIndex, pairIndex, long, BigInt(Math.round(positionSizeToken * 1e18)), // Convert to 1e18 precision
+        open);
+        // Convert from int256 1e10 to percentage
+        return Number(priceImpactP) / 1e10;
+    }
+    catch (error) {
+        console.error("Error calculating trade skew price impact:", error);
+        throw error;
+    }
+});
+exports.calculateTradeSkewPriceImpact = calculateTradeSkewPriceImpact;

package/lib/contracts/index.js

@@ -63,6 +63,7 @@ exports.COLLATERAL_TO_CHAIN_COLLATERAL_INDEX = {
     },
     [types_1.ChainId.BASE]: {
         [types_1.CollateralTypes.USDC]: 1,
+        [types_1.CollateralTypes.BTCUSD]: 2,
     },
     [types_1.ChainId.APECHAIN]: {
         [types_1.CollateralTypes.APE]: 1,
@@ -75,7 +76,8 @@ exports.COLLATERAL_TO_COLLATERAL_INDEX = {
     [types_1.CollateralTypes.USDC]: 3,
     [types_1.CollateralTypes.ARB]: 0,
     [types_1.CollateralTypes.APE]: 0,
-    [types_1.CollateralTypes.GNS]: 0, // not in use
+    [types_1.CollateralTypes.GNS]: 0,
+    [types_1.CollateralTypes.BTCUSD]: 0,
 };
 __exportStar(require("./utils"), exports);
 __exportStar(require("./addresses"), exports);

package/lib/contracts/types/index.d.ts

@@ -16,7 +16,8 @@ export declare enum CollateralTypes {
     ARB = "ARB",
     USDC = "USDC",
     APE = "APE",
-    GNS = "GNS"
+    GNS = "GNS",
+    BTCUSD = "BTCUSD"
 }
 export declare enum ContractsVersion {
     BEFORE_V9_2 = 0,

package/lib/contracts/types/index.js

@@ -9,6 +9,7 @@ var CollateralTypes;
     CollateralTypes["USDC"] = "USDC";
     CollateralTypes["APE"] = "APE";
     CollateralTypes["GNS"] = "GNS";
+    CollateralTypes["BTCUSD"] = "BTCUSD";
 })(CollateralTypes = exports.CollateralTypes || (exports.CollateralTypes = {}));
 var ContractsVersion;
 (function (ContractsVersion) {

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

@@ -0,0 +1,66 @@
+import type { IFundingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { BorrowingFeeV2 } from ".";
+/**
+ * @dev Converts contract BorrowingFeeParams to SDK type
+ * @param contractParams Contract borrowing fee params from IFundingFees.BorrowingFeeParams
+ * @returns SDK BorrowingFeeParams
+ */
+export declare const convertBorrowingFeeParams: (contractParams: IFundingFees.BorrowingFeeParamsStructOutput) => BorrowingFeeV2.BorrowingFeeParams;
+/**
+ * @dev Converts array of contract BorrowingFeeParams to SDK types
+ * @param contractParamsArray Array of contract borrowing fee params
+ * @returns Array of SDK BorrowingFeeParams
+ */
+export declare const convertBorrowingFeeParamsArray: (contractParamsArray: IFundingFees.BorrowingFeeParamsStructOutput[]) => BorrowingFeeV2.BorrowingFeeParams[];
+/**
+ * @dev Converts contract PairBorrowingFeeData to SDK type
+ * @param contractData Contract pair borrowing fee data from IFundingFees.PairBorrowingFeeData
+ * @returns SDK PairBorrowingFeeData
+ */
+export declare const convertPairBorrowingFeeData: (contractData: IFundingFees.PairBorrowingFeeDataStructOutput) => BorrowingFeeV2.PairBorrowingFeeData;
+/**
+ * @dev Converts array of contract PairBorrowingFeeData to SDK types
+ * @param contractDataArray Array of contract pair borrowing fee data
+ * @returns Array of SDK PairBorrowingFeeData
+ */
+export declare const convertPairBorrowingFeeDataArray: (contractDataArray: IFundingFees.PairBorrowingFeeDataStructOutput[]) => BorrowingFeeV2.PairBorrowingFeeData[];
+/**
+ * @dev Converts contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeData Contract trade fees data from IFundingFees.TradeFeesData
+ * @returns SDK TradeInitialAccFees
+ */
+export declare const convertTradeInitialAccFees: (contractTradeData: IFundingFees.TradeFeesDataStructOutput) => BorrowingFeeV2.TradeInitialAccFees;
+/**
+ * @dev Converts array of contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeDataArray Array of contract trade fees data
+ * @returns Array of SDK TradeInitialAccFees
+ */
+export declare const convertTradeInitialAccFeesArray: (contractTradeDataArray: IFundingFees.TradeFeesDataStructOutput[]) => BorrowingFeeV2.TradeInitialAccFees[];
+/**
+ * @dev Creates a context object from contract data arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param borrowingParams Array of borrowing fee params from contract
+ * @param borrowingData Array of pair borrowing fee data from contract
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete SDK context for borrowing v2 calculations
+ */
+export declare const createBorrowingV2Context: (collateralIndices: number[], pairIndices: number[], borrowingParams: IFundingFees.BorrowingFeeParamsStructOutput[], borrowingData: IFundingFees.PairBorrowingFeeDataStructOutput[], currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;
+/**
+ * @dev Helper function to validate borrowing rate per second
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns True if rate is within valid bounds
+ */
+export declare const isValidBorrowingRate: (borrowingRatePerSecondP: number) => boolean;
+/**
+ * @dev Helper function to convert borrowing rate to APR percentage
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns APR as percentage (e.g., 10.5 for 10.5% APR)
+ */
+export declare const borrowingRateToAPR: (borrowingRatePerSecondP: number) => number;
+/**
+ * @dev Helper function to convert APR percentage to borrowing rate per second
+ * @param aprPercentage APR as percentage (e.g., 10.5 for 10.5% APR)
+ * @returns Borrowing rate per second (normalized float)
+ */
+export declare const aprToBorrowingRate: (aprPercentage: number) => number;

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aprToBorrowingRate = exports.borrowingRateToAPR = exports.isValidBorrowingRate = exports.createBorrowingV2Context = exports.convertTradeInitialAccFeesArray = exports.convertTradeInitialAccFees = exports.convertPairBorrowingFeeDataArray = exports.convertPairBorrowingFeeData = exports.convertBorrowingFeeParamsArray = exports.convertBorrowingFeeParams = void 0;
+const index_1 = require("./index");
+/**
+ * @dev Converts contract BorrowingFeeParams to SDK type
+ * @param contractParams Contract borrowing fee params from IFundingFees.BorrowingFeeParams
+ * @returns SDK BorrowingFeeParams
+ */
+const convertBorrowingFeeParams = (contractParams) => ({
+    borrowingRatePerSecondP: contractParams.borrowingRatePerSecondP /
+        index_1.BORROWING_V2_PRECISION.RATE_PER_SECOND,
+});
+exports.convertBorrowingFeeParams = convertBorrowingFeeParams;
+/**
+ * @dev Converts array of contract BorrowingFeeParams to SDK types
+ * @param contractParamsArray Array of contract borrowing fee params
+ * @returns Array of SDK BorrowingFeeParams
+ */
+const convertBorrowingFeeParamsArray = (contractParamsArray) => contractParamsArray.map(params => (0, exports.convertBorrowingFeeParams)(params));
+exports.convertBorrowingFeeParamsArray = convertBorrowingFeeParamsArray;
+/**
+ * @dev Converts contract PairBorrowingFeeData to SDK type
+ * @param contractData Contract pair borrowing fee data from IFundingFees.PairBorrowingFeeData
+ * @returns SDK PairBorrowingFeeData
+ */
+const convertPairBorrowingFeeData = (contractData) => ({
+    accBorrowingFeeP: parseFloat(contractData.accBorrowingFeeP.toString()) /
+        index_1.BORROWING_V2_PRECISION.ACC_FEE,
+    lastBorrowingUpdateTs: contractData.lastBorrowingUpdateTs,
+});
+exports.convertPairBorrowingFeeData = convertPairBorrowingFeeData;
+/**
+ * @dev Converts array of contract PairBorrowingFeeData to SDK types
+ * @param contractDataArray Array of contract pair borrowing fee data
+ * @returns Array of SDK PairBorrowingFeeData
+ */
+const convertPairBorrowingFeeDataArray = (contractDataArray) => contractDataArray.map(data => (0, exports.convertPairBorrowingFeeData)(data));
+exports.convertPairBorrowingFeeDataArray = convertPairBorrowingFeeDataArray;
+/**
+ * @dev Converts contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeData Contract trade fees data from IFundingFees.TradeFeesData
+ * @returns SDK TradeInitialAccFees
+ */
+const convertTradeInitialAccFees = (contractTradeData) => ({
+    initialAccBorrowingFeeP: parseFloat(contractTradeData.initialAccBorrowingFeeP.toString()) /
+        index_1.BORROWING_V2_PRECISION.ACC_FEE,
+});
+exports.convertTradeInitialAccFees = convertTradeInitialAccFees;
+/**
+ * @dev Converts array of contract TradeFeesData to SDK TradeInitialAccFees
+ * @param contractTradeDataArray Array of contract trade fees data
+ * @returns Array of SDK TradeInitialAccFees
+ */
+const convertTradeInitialAccFeesArray = (contractTradeDataArray) => contractTradeDataArray.map(data => (0, exports.convertTradeInitialAccFees)(data));
+exports.convertTradeInitialAccFeesArray = convertTradeInitialAccFeesArray;
+/**
+ * @dev Creates a context object from contract data arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param borrowingParams Array of borrowing fee params from contract
+ * @param borrowingData Array of pair borrowing fee data from contract
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete SDK context for borrowing v2 calculations
+ */
+const createBorrowingV2Context = (collateralIndices, pairIndices, borrowingParams, borrowingData, currentTimestamp) => {
+    const context = {
+        currentTimestamp,
+        borrowingParams: {},
+        borrowingData: {},
+    };
+    // 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.borrowingParams[collateralIndex]) {
+            context.borrowingParams[collateralIndex] = {};
+        }
+        if (!context.borrowingData[collateralIndex]) {
+            context.borrowingData[collateralIndex] = {};
+        }
+        // Store converted data
+        context.borrowingParams[collateralIndex][pairIndex] =
+            (0, exports.convertBorrowingFeeParams)(borrowingParams[i]);
+        context.borrowingData[collateralIndex][pairIndex] =
+            (0, exports.convertPairBorrowingFeeData)(borrowingData[i]);
+    }
+    return context;
+};
+exports.createBorrowingV2Context = createBorrowingV2Context;
+/**
+ * @dev Helper function to validate borrowing rate per second
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns True if rate is within valid bounds
+ */
+const isValidBorrowingRate = (borrowingRatePerSecondP) => {
+    return (borrowingRatePerSecondP >= 0 &&
+        borrowingRatePerSecondP <= 317097 / index_1.BORROWING_V2_PRECISION.RATE_PER_SECOND); // Max 1,000% APR
+};
+exports.isValidBorrowingRate = isValidBorrowingRate;
+/**
+ * @dev Helper function to convert borrowing rate to APR percentage
+ * @param borrowingRatePerSecondP Borrowing rate per second (normalized float)
+ * @returns APR as percentage (e.g., 10.5 for 10.5% APR)
+ */
+const borrowingRateToAPR = (borrowingRatePerSecondP) => {
+    const SECONDS_PER_YEAR = 365 * 24 * 60 * 60; // 31,536,000
+    return borrowingRatePerSecondP * SECONDS_PER_YEAR;
+};
+exports.borrowingRateToAPR = borrowingRateToAPR;
+/**
+ * @dev Helper function to convert APR percentage to borrowing rate per second
+ * @param aprPercentage APR as percentage (e.g., 10.5 for 10.5% APR)
+ * @returns Borrowing rate per second (normalized float)
+ */
+const aprToBorrowingRate = (aprPercentage) => {
+    const SECONDS_PER_YEAR = 365 * 24 * 60 * 60; // 31,536,000
+    return aprPercentage / SECONDS_PER_YEAR;
+};
+exports.aprToBorrowingRate = aprToBorrowingRate;

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

@@ -0,0 +1,59 @@
+import * as BorrowingFeeV2 from "./types";
+/**
+ * @dev Maximum borrowing rate per second (1,000% APR)
+ */
+export declare const MAX_BORROWING_RATE_PER_SECOND = 0.0317097;
+/**
+ * @dev Precision constants for borrowing v2 calculations
+ */
+export declare const BORROWING_V2_PRECISION: {
+    readonly RATE_PER_SECOND: 10000000000;
+    readonly ACC_FEE: 100000000000000000000;
+    readonly 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)
+ */
+export declare const getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
+/**
+ * @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
+ */
+export declare const getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @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
+ */
+export declare const getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @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)
+ */
+export declare const getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+/**
+ * @dev Utility functions for working with borrowing v2 fees
+ */
+export declare const borrowingFeeV2Utils: {
+    getPairPendingAccBorrowingFees: (params: BorrowingFeeV2.BorrowingFeeParams, data: BorrowingFeeV2.PairBorrowingFeeData, currentPairPrice: number, currentTimestamp?: number) => number;
+    getTradeBorrowingFeesCollateral: (input: BorrowingFeeV2.TradeBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+    getPairBorrowingFees: (input: BorrowingFeeV2.PairBorrowingFeeInput, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+    getBorrowingFee: (positionSizeCollateral: number, pairIndex: number, collateralIndex: number, openPrice: number, currentPairPrice: number, initialAccBorrowingFeeP: number, context: BorrowingFeeV2.GetBorrowingFeeV2Context) => number;
+};
+export * as BorrowingFeeV2 from "./types";
+export * from "./converter";

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

@@ -0,0 +1,139 @@
+"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);

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;
+};