@gainsnetwork/sdk 0.2.67-rc6 → 0.2.68

package/lib/constants.js

@@ -446,8 +446,7 @@ exports.delistedPairIxs = new Set([
     99, 101, 106, 111, 113, 114, 116, 118, 120, 122, 123, 125, 127, 130, 147, 152,
     160, 163, 170, 179, 182, 183, 187, 188, 189, 190, 208, 209, 225, 229, 230,
     231, 238, 239, 241, 250, 253, 254, 258, 270, 275, 276, 278, 279, 282, 285,
-    290, 294, 296, 305, 330, 349, 352, 353, 354, 355, 357, 365, 366, 377, 378,
-    379, 384, 385,
+    290, 294, 296, 305, 330, 349, 352, 353, 354, 355, 357, 365, 366, 384, 385,
 ]);
 exports.delistedGroupsIxs = new Set([]);
 exports.DEFAULT_PROTECTION_CLOSE_FACTOR = 1;

package/lib/contracts/addresses.json

@@ -22,6 +22,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "42161": {
@@ -47,6 +51,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x4ca1638754Be8060E544Aca4A4F43702Be30E0D1",
             "gToken": "0x4BeeF1113F968326905224D2Ca272f3032A9a9F4"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "421614": {
@@ -72,6 +80,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x68F8D4ec2EF23a15e61e1642E730b6f69fB9A5De",
             "gToken": "0x5ed4bEA869300DB39bE2a92a8B42e53453742a43"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "8453": {
@@ -97,6 +109,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0xA22F7b92d81Dd74bE5ca5758DF3FccF0A4CB19cc",
+            "gToken": "0xB7Cb7cB7C3cD96e251c9bF8800B9631134BbAdc6"
         }
     },
     "33139": {
@@ -122,6 +138,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     }
 }

package/lib/contracts/fetch/fees/borrowingFeesV2.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="mocha" />
+import type { GNSMultiCollatDiamond } from "../../types/generated";
+import { BorrowingFeeV2 } from "../../../trade/fees/borrowingV2";
+/**
+ * @dev Fetches borrowing fee parameters v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of borrowing fee parameters
+ */
+export declare const fetchBorrowingFeeParamsV2: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.BorrowingFeeParams[]>;
+/**
+ * @dev Fetches pair borrowing fee data v2 for specific 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 borrowing fee data
+ */
+export declare const fetchPairBorrowingFeeDataV2: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.PairBorrowingFeeData[]>;
+/**
+ * @dev Fetches borrowing fees in collateral tokens for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Address of the trader
+ * @param index Trade index
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to borrowing fees in collateral tokens
+ */
+export declare const fetchTradeBorrowingFeesCollateralV2: (contract: GNSMultiCollatDiamond, trader: string, index: number, currentPairPrice: number) => Promise<number>;
+/**
+ * @dev Fetches pending accumulated borrowing fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndex Index of the trading pair
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to pending accumulated borrowing fee
+ */
+export declare const fetchPairPendingAccBorrowingFeesV2: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, currentPairPrice: number) => Promise<number>;
+/**
+ * @dev Convenience function to fetch all borrowing v2 data for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to complete borrowing v2 data set
+ */
+export declare const fetchAllBorrowingV2Data: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndices: number[]) => Promise<{
+    params: BorrowingFeeV2.BorrowingFeeParams[];
+    data: BorrowingFeeV2.PairBorrowingFeeData[];
+    context: BorrowingFeeV2.GetBorrowingFeeV2Context;
+}>;
+/**
+ * @dev Creates a complete borrowing v2 context from contract data
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @param currentTimestamp Optional current timestamp for calculations
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+export declare const createBorrowingV2ContextFromContract: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndices: number[], currentTimestamp?: number) => Promise<BorrowingFeeV2.GetBorrowingFeeV2Context>;
+/**
+ * @dev Helper function to create context from already fetched arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of borrowing fee parameters
+ * @param data Array of pair borrowing fee data
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete borrowing v2 context
+ */
+export declare const createBorrowingV2ContextFromArrays: (collateralIndices: number[], pairIndices: number[], params: BorrowingFeeV2.BorrowingFeeParams[], data: BorrowingFeeV2.PairBorrowingFeeData[], currentTimestamp?: number) => BorrowingFeeV2.GetBorrowingFeeV2Context;
+/**
+ * @dev Fetches borrowing v2 data for multiple collateral/pair combinations
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices (must match collateralIndices length)
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+export declare const fetchBorrowingV2DataForPairs: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<BorrowingFeeV2.GetBorrowingFeeV2Context>;

package/lib/contracts/fetch/fees/borrowingFeesV2.js

@@ -0,0 +1,193 @@
+"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.fetchBorrowingV2DataForPairs = exports.createBorrowingV2ContextFromArrays = exports.createBorrowingV2ContextFromContract = exports.fetchAllBorrowingV2Data = exports.fetchPairPendingAccBorrowingFeesV2 = exports.fetchTradeBorrowingFeesCollateralV2 = exports.fetchPairBorrowingFeeDataV2 = exports.fetchBorrowingFeeParamsV2 = void 0;
+const converter_1 = require("../../../trade/fees/borrowingV2/converter");
+/**
+ * @dev Fetches borrowing fee parameters v2 for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to array of borrowing fee parameters
+ */
+const fetchBorrowingFeeParamsV2 = (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 contractParams = yield contract.getPairBorrowingFeeParams(collateralIndices, pairIndices);
+        return (0, converter_1.convertBorrowingFeeParamsArray)(contractParams);
+    }
+    catch (error) {
+        console.error("Error fetching borrowing fee params v2:", error);
+        throw error;
+    }
+});
+exports.fetchBorrowingFeeParamsV2 = fetchBorrowingFeeParamsV2;
+/**
+ * @dev Fetches pair borrowing fee data v2 for specific 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 borrowing fee data
+ */
+const fetchPairBorrowingFeeDataV2 = (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 contractData = yield contract.getPairBorrowingFeeData(collateralIndices, pairIndices);
+        return (0, converter_1.convertPairBorrowingFeeDataArray)(contractData);
+    }
+    catch (error) {
+        console.error("Error fetching pair borrowing fee data v2:", error);
+        throw error;
+    }
+});
+exports.fetchPairBorrowingFeeDataV2 = fetchPairBorrowingFeeDataV2;
+/**
+ * @dev Fetches borrowing fees in collateral tokens for a specific trade
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param trader Address of the trader
+ * @param index Trade index
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to borrowing fees in collateral tokens
+ */
+const fetchTradeBorrowingFeesCollateralV2 = (contract, trader, index, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const feesCollateral = yield contract.getTradeBorrowingFeesCollateral(trader, index, currentPairPrice);
+        // Convert BigNumber to normalized float
+        // Note: Collateral precision varies by chain, but contract returns proper precision
+        return parseFloat(feesCollateral.toString());
+    }
+    catch (error) {
+        console.error("Error fetching trade borrowing fees collateral v2:", error);
+        throw error;
+    }
+});
+exports.fetchTradeBorrowingFeesCollateralV2 = fetchTradeBorrowingFeesCollateralV2;
+/**
+ * @dev Fetches pending accumulated borrowing fees for a specific pair
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndex Index of the trading pair
+ * @param currentPairPrice Current price of the trading pair (1e6 precision)
+ * @returns Promise resolving to pending accumulated borrowing fee
+ */
+const fetchPairPendingAccBorrowingFeesV2 = (contract, collateralIndex, pairIndex, currentPairPrice) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const accBorrowingFeeP = yield contract.getPairPendingAccBorrowingFees(collateralIndex, pairIndex, currentPairPrice);
+        // Convert BigNumber to normalized float
+        return parseFloat(accBorrowingFeeP.toString()) / 1e20;
+    }
+    catch (error) {
+        console.error("Error fetching pair pending acc borrowing fees v2:", error);
+        throw error;
+    }
+});
+exports.fetchPairPendingAccBorrowingFeesV2 = fetchPairPendingAccBorrowingFeesV2;
+/**
+ * @dev Convenience function to fetch all borrowing v2 data for specific pairs
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @returns Promise resolving to complete borrowing v2 data set
+ */
+const fetchAllBorrowingV2Data = (contract, collateralIndex, pairIndices) => __awaiter(void 0, void 0, void 0, function* () {
+    const collateralIndices = new Array(pairIndices.length).fill(collateralIndex);
+    try {
+        // Fetch both parameters and data in parallel
+        const [params, data] = yield Promise.all([
+            (0, exports.fetchBorrowingFeeParamsV2)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairBorrowingFeeDataV2)(contract, collateralIndices, pairIndices),
+        ]);
+        // Create context from fetched data
+        const context = (0, exports.createBorrowingV2ContextFromArrays)(collateralIndices, pairIndices, params, data);
+        return { params, data, context };
+    }
+    catch (error) {
+        console.error("Error fetching all borrowing v2 data:", error);
+        throw error;
+    }
+});
+exports.fetchAllBorrowingV2Data = fetchAllBorrowingV2Data;
+/**
+ * @dev Creates a complete borrowing v2 context from contract data
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndex Index of the collateral
+ * @param pairIndices Array of pair indices
+ * @param currentTimestamp Optional current timestamp for calculations
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+const createBorrowingV2ContextFromContract = (contract, collateralIndex, pairIndices, currentTimestamp) => __awaiter(void 0, void 0, void 0, function* () {
+    const { context } = yield (0, exports.fetchAllBorrowingV2Data)(contract, collateralIndex, pairIndices);
+    return Object.assign(Object.assign({}, context), { currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000) });
+});
+exports.createBorrowingV2ContextFromContract = createBorrowingV2ContextFromContract;
+/**
+ * @dev Helper function to create context from already fetched arrays
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices
+ * @param params Array of borrowing fee parameters
+ * @param data Array of pair borrowing fee data
+ * @param currentTimestamp Optional current timestamp
+ * @returns Complete borrowing v2 context
+ */
+const createBorrowingV2ContextFromArrays = (collateralIndices, pairIndices, params, data, currentTimestamp) => {
+    const context = {
+        currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000),
+        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 data
+        context.borrowingParams[collateralIndex][pairIndex] = params[i];
+        context.borrowingData[collateralIndex][pairIndex] = data[i];
+    }
+    return context;
+};
+exports.createBorrowingV2ContextFromArrays = createBorrowingV2ContextFromArrays;
+/**
+ * @dev Fetches borrowing v2 data for multiple collateral/pair combinations
+ * @param contract GNSMultiCollatDiamond contract instance
+ * @param collateralIndices Array of collateral indices
+ * @param pairIndices Array of pair indices (must match collateralIndices length)
+ * @returns Promise resolving to complete borrowing v2 context
+ */
+const fetchBorrowingV2DataForPairs = (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 {
+        // Fetch both parameters and data in parallel
+        const [params, data] = yield Promise.all([
+            (0, exports.fetchBorrowingFeeParamsV2)(contract, collateralIndices, pairIndices),
+            (0, exports.fetchPairBorrowingFeeDataV2)(contract, collateralIndices, pairIndices),
+        ]);
+        // Create and return context
+        return (0, exports.createBorrowingV2ContextFromArrays)(collateralIndices, pairIndices, params, data);
+    }
+    catch (error) {
+        console.error("Error fetching borrowing v2 data for pairs:", error);
+        throw error;
+    }
+});
+exports.fetchBorrowingV2DataForPairs = fetchBorrowingV2DataForPairs;

package/lib/contracts/fetch/fees/fundingFees.d.ts

@@ -0,0 +1,66 @@
+import type { GNSMultiCollatDiamond } from "../../types/generated";
+import type { TradeInitialAccFees } from "../../../trade/fees/fundingFees";
+/**
+ * @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/contracts/fetch/fees/fundingFees.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/contracts/fetch/priceImpact/skew.d.ts

@@ -0,0 +1,63 @@
+import type { GNSMultiCollatDiamond } from "../../types/generated";
+import type { PairOiToken, SkewPriceImpactContext } from "../../../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
+ */
+export declare const fetchPairOiAfterV10Token: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number) => Promise<PairOiToken>;
+/**
+ * @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
+ */
+export declare const fetchPairOisAfterV10Token: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[]) => Promise<PairOiToken[]>;
+/**
+ * @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
+ */
+export declare const fetchPairSkewDepth: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, collateralDecimals: number) => Promise<number>;
+/**
+ * @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
+ */
+export declare const fetchPairSkewDepths: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[], collateralDecimals: number[]) => Promise<number[]>;
+/**
+ * @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
+ */
+export declare const fetchSkewPriceImpactContext: (contract: GNSMultiCollatDiamond, collateralIndices: number[], pairIndices: number[], collateralDecimals: number[]) => Promise<SkewPriceImpactContext>;
+/**
+ * @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
+ */
+export declare const fetchCollateralDecimals: (contract: GNSMultiCollatDiamond, collateralIndices: number[]) => Promise<number[]>;
+/**
+ * @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)
+ */
+export declare const calculateTradeSkewPriceImpact: (contract: GNSMultiCollatDiamond, collateralIndex: number, pairIndex: number, long: boolean, positionSizeToken: number, open: boolean) => Promise<number>;