@gainsnetwork/sdk 1.5.0-rc2 → 1.5.0-rc4

package/lib/trade/effectiveLeverage/builder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTradeEffectiveLeverageContext = void 0;
+const __1 = require("..");
+/**
+ * @dev Builds a complete context for effective leverage calculations
+ * @dev Uses the closing price impact context builder as a sub-context
+ * @param globalTradingVariables The transformed global trading variables from backend
+ * @param collateralIndex The collateral index (1-based)
+ * @param pairIndex The pair index
+ * @param tradeInfo Trade information including createdBlock
+ * @param additionalParams Additional parameters for price impact calculations
+ * @returns Complete context ready for getTradeNewEffectiveLeverage
+ */
+const buildTradeEffectiveLeverageContext = (globalTradingVariables, collateralIndex, pairIndex, tradeInfo, additionalParams) => {
+    var _a;
+    // Build the closing price impact context which we'll use for PnL calculations
+    const closingPriceImpactContext = (0, __1.buildTradeClosingPriceImpactContext)(globalTradingVariables, collateralIndex, pairIndex, tradeInfo, additionalParams);
+    if (!closingPriceImpactContext) {
+        return undefined;
+    }
+    // Extract base spread from pairs data
+    const pairs = globalTradingVariables.pairs;
+    const baseSpreadP = ((_a = pairs === null || pairs === void 0 ? void 0 : pairs[pairIndex]) === null || _a === void 0 ? void 0 : _a.spreadP) || 0;
+    return {
+        closingPriceImpactContext,
+        baseSpreadP,
+    };
+};
+exports.buildTradeEffectiveLeverageContext = buildTradeEffectiveLeverageContext;

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

@@ -1,4 +1,3 @@
-/// <reference types="mocha" />
 import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
 import { BorrowingFeeV2 } from ".";
 /**

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

@@ -0,0 +1,46 @@
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+import { FundingFeeParams, PairFundingFeeData, PairOiAfterV10 } from "../fundingFees/types";
+import { BorrowingFeeParams, PairBorrowingFeeData } from "../borrowingV2/types";
+export type HoldingFeeRates = {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+};
+export type GetPairHoldingFeeRatesInput = {
+    fundingParams: FundingFeeParams;
+    fundingData: PairFundingFeeData;
+    pairOiToken: PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: BorrowingFeeParams | null;
+    borrowingData: PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+};
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+export declare const getPairHoldingFeeRates: (input: GetPairHoldingFeeRatesInput) => HoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+export declare const convertRatePerSecondToAPR: (ratePerSecond: number) => number;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+export declare const formatHoldingFeeRate: (rate: number, decimals?: number) => string;
+export * as HoldingFees from "./types";

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

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * @dev Holding fees calculation utilities for v10+ markets
+ * @dev Combines funding fees and borrowing v2 fees
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoldingFees = exports.formatHoldingFeeRate = exports.convertRatePerSecondToAPR = exports.getPairHoldingFeeRates = void 0;
+const fundingFees_1 = require("../fundingFees");
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+const PERCENTAGE_PRECISION = 100;
+/**
+ * @dev Calculates current holding fee rates per hour for display
+ * @param input Input parameters for calculation
+ * @returns Holding fee rates per hour with breakdown
+ */
+const getPairHoldingFeeRates = (input) => {
+    const { fundingParams, fundingData, pairOiToken, netExposureToken, netExposureUsd, borrowingParams, borrowingData, currentPairPrice, currentTimestamp, } = input;
+    // Calculate funding fee rates
+    let fundingFeeLongHourlyRate = 0;
+    let fundingFeeShortHourlyRate = 0;
+    let currentFundingRatePerSecondP = 0;
+    if (fundingParams.fundingFeesEnabled) {
+        // Get current funding rate
+        const pendingFunding = (0, fundingFees_1.getPairPendingAccFundingFees)(fundingParams, fundingData, currentPairPrice, pairOiToken, netExposureToken, netExposureUsd, currentTimestamp);
+        currentFundingRatePerSecondP = pendingFunding.currentFundingRatePerSecondP;
+        // Get APR multipliers
+        const { longAprMultiplier, shortAprMultiplier } = (0, fundingFees_1.getLongShortAprMultiplier)(currentFundingRatePerSecondP, pairOiToken.oiLongToken, pairOiToken.oiShortToken, fundingParams.aprMultiplierEnabled);
+        // Calculate hourly rates
+        // Funding rate * seconds per hour * current price * APR multiplier / 100
+        const baseHourlyRate = (currentFundingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+            PERCENTAGE_PRECISION;
+        // Long side pays when rate is positive, earns when negative
+        fundingFeeLongHourlyRate = baseHourlyRate * longAprMultiplier;
+        // Short side is opposite
+        fundingFeeShortHourlyRate = -baseHourlyRate * shortAprMultiplier;
+    }
+    // Calculate borrowing v2 rates
+    let borrowingFeeHourlyRate = 0;
+    let currentBorrowingRatePerSecondP = 0;
+    if (borrowingParams && borrowingData) {
+        currentBorrowingRatePerSecondP = borrowingParams.borrowingRatePerSecondP;
+        // Borrowing rate * seconds per hour * current price / 100
+        borrowingFeeHourlyRate =
+            (currentBorrowingRatePerSecondP * SECONDS_PER_HOUR * currentPairPrice) /
+                PERCENTAGE_PRECISION;
+    }
+    // Total holding fees (funding can be negative/positive, borrowing always positive cost)
+    const longHourlyRate = fundingFeeLongHourlyRate + borrowingFeeHourlyRate;
+    const shortHourlyRate = fundingFeeShortHourlyRate + borrowingFeeHourlyRate;
+    return {
+        longHourlyRate,
+        shortHourlyRate,
+        fundingFeeLongHourlyRate,
+        fundingFeeShortHourlyRate,
+        borrowingFeeHourlyRate,
+        currentFundingRatePerSecondP,
+        currentBorrowingRatePerSecondP,
+    };
+};
+exports.getPairHoldingFeeRates = getPairHoldingFeeRates;
+/**
+ * @dev Converts a per-second rate to annual percentage rate (APR)
+ * @param ratePerSecond Rate per second
+ * @returns Annual percentage rate
+ */
+const convertRatePerSecondToAPR = (ratePerSecond) => {
+    return ratePerSecond * SECONDS_PER_YEAR * PERCENTAGE_PRECISION;
+};
+exports.convertRatePerSecondToAPR = convertRatePerSecondToAPR;
+/**
+ * @dev Formats a holding fee rate for display
+ * @param rate Hourly rate (can be negative)
+ * @param decimals Number of decimal places
+ * @returns Formatted string with sign
+ */
+const formatHoldingFeeRate = (rate, decimals = 4) => {
+    const sign = rate > 0 ? "+" : "";
+    return `${sign}${rate.toFixed(decimals)}%`;
+};
+exports.formatHoldingFeeRate = formatHoldingFeeRate;
+exports.HoldingFees = __importStar(require("./types"));

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

@@ -0,0 +1,23 @@
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+export interface HoldingFeeRates {
+    longHourlyRate: number;
+    shortHourlyRate: number;
+    fundingFeeLongHourlyRate: number;
+    fundingFeeShortHourlyRate: number;
+    borrowingFeeHourlyRate: number;
+    currentFundingRatePerSecondP: number;
+    currentBorrowingRatePerSecondP: number;
+}
+export interface GetPairHoldingFeeRatesInput {
+    fundingParams: import("../fundingFees/types").FundingFeeParams;
+    fundingData: import("../fundingFees/types").PairFundingFeeData;
+    pairOiToken: import("../fundingFees/types").PairOiAfterV10;
+    netExposureToken: number;
+    netExposureUsd: number;
+    borrowingParams: import("../borrowingV2/types").BorrowingFeeParams | null;
+    borrowingData: import("../borrowingV2/types").PairBorrowingFeeData | null;
+    currentPairPrice: number;
+    currentTimestamp: number;
+}

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Type definitions for holding fees (funding + borrowing v2)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,28 @@
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../../types";
+import { TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+import type { BorrowingV1SubContext, BorrowingV2SubContext, FundingFeesSubContext } from "../../pnl";
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: BorrowingV1SubContext;
+    borrowingV2?: BorrowingV2SubContext;
+    funding?: FundingFeesSubContext;
+};
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateralStructured: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const pairContext_1 = require("../fundingFees/pairContext");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, pairContext_1.getPairTradeFundingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            long: trade.long,
+            currentPairPrice,
+            initialAccFundingFeeP: tradeFeesData.initialAccFundingFeeP,
+        }, context.funding // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 && tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getPairTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getPairBorrowingFee)(positionSizeCollateral, trade.long, context.borrowingV1.initialAccFees || { accPairFee: 0, accGroupFee: 0, block: 0 }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

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

@@ -0,0 +1,28 @@
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+import { Trade, TradeInfo, TradeFeesData } from "../../types";
+import { TradeHoldingFees } from "./types";
+import { ContractsVersion } from "../../../contracts/types";
+import type { BorrowingV1SubContext, BorrowingV2SubContext, FundingFeesSubContext } from "../../pnl";
+/**
+ * @dev Context for holding fees calculation with structured sub-contexts
+ */
+export type GetStructuredHoldingFeesContext = {
+    contractsVersion: ContractsVersion;
+    currentTimestamp: number;
+    collateralPriceUsd: number;
+    borrowingV1?: BorrowingV1SubContext;
+    borrowingV2?: BorrowingV2SubContext;
+    funding?: FundingFeesSubContext;
+};
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+export declare const getTradePendingHoldingFeesCollateralStructured: (trade: Trade, tradeInfo: TradeInfo, tradeFeesData: TradeFeesData, currentPairPrice: number, context: GetStructuredHoldingFeesContext) => TradeHoldingFees;

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @dev Holding fees calculation for structured contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradePendingHoldingFeesCollateralStructured = void 0;
+const types_1 = require("../../../contracts/types");
+const borrowing_1 = require("../borrowing");
+const borrowingV2_1 = require("../borrowingV2");
+const fundingFees_1 = require("../fundingFees");
+/**
+ * @dev Calculates total holding fees using structured context
+ * @param trade The trade to calculate fees for
+ * @param tradeInfo Trade info containing contracts version
+ * @param tradeFeesData Trade fees data containing initial acc fees
+ * @param currentPairPrice Current pair price
+ * @param context Structured context with sub-contexts for each fee type
+ * @returns Object containing all holding fee components
+ */
+const getTradePendingHoldingFeesCollateralStructured = (trade, tradeInfo, tradeFeesData, currentPairPrice, context) => {
+    const positionSizeCollateral = trade.collateralAmount * trade.leverage;
+    // Calculate funding fees (v10+ only)
+    let fundingFeeCollateral = 0;
+    if (context.contractsVersion >= types_1.ContractsVersion.V10 &&
+        context.funding &&
+        tradeFeesData.initialAccFundingFeeP !== undefined) {
+        fundingFeeCollateral = (0, fundingFees_1.getTradeFundingFeesCollateral)(trade, tradeInfo, tradeFeesData, currentPairPrice, Object.assign(Object.assign({}, context.funding), { currentTimestamp: context.currentTimestamp }) // TODO: Fix types once funding types are properly imported
+        );
+    }
+    // Calculate borrowing fees v2
+    let borrowingFeeCollateral = 0;
+    if (context.borrowingV2 &&
+        tradeFeesData.initialAccBorrowingFeeP !== undefined) {
+        borrowingFeeCollateral = (0, borrowingV2_1.getTradeBorrowingFeesCollateral)({
+            positionSizeCollateral,
+            openPrice: trade.openPrice,
+            currentPairPrice,
+            initialAccBorrowingFeeP: tradeFeesData.initialAccBorrowingFeeP,
+            currentTimestamp: context.currentTimestamp,
+        }, context.borrowingV2);
+    }
+    // Calculate v1 borrowing fees (some markets use v1 indefinitely)
+    let borrowingFeeCollateral_old = 0;
+    if (context.borrowingV1) {
+        borrowingFeeCollateral_old = (0, borrowing_1.getBorrowingFee)(positionSizeCollateral, undefined, // pairIndex not needed for pair-specific context
+        trade.long, context.borrowingV1.initialAccFees || {
+            accPairFee: 0,
+            accGroupFee: 0,
+            block: 0,
+        }, {
+            currentBlock: context.borrowingV1.currentBlock,
+            group: context.borrowingV1.group,
+            pair: context.borrowingV1.pair,
+            collateralPriceUsd: context.collateralPriceUsd,
+        });
+    }
+    return {
+        fundingFeeCollateral,
+        borrowingFeeCollateral,
+        borrowingFeeCollateral_old,
+        totalFeeCollateral: fundingFeeCollateral +
+            borrowingFeeCollateral +
+            borrowingFeeCollateral_old,
+    };
+};
+exports.getTradePendingHoldingFeesCollateralStructured = getTradePendingHoldingFeesCollateralStructured;

package/lib/trade/priceImpact/cumulVol/index.js

@@ -80,8 +80,6 @@ exports.getLegacyFactor = getLegacyFactor;
  * @returns Price impact percentage
  */
 const _calculateDepthBandsPriceImpact = (tradeSizeUsd, depthBandParams) => {
-    console.log("tradeSizeUsd", tradeSizeUsd);
-    console.log("depthBandParams", depthBandParams);
     const totalDepthUsd = depthBandParams.depthBands.totalDepthUsd;
     if (totalDepthUsd === 0 || tradeSizeUsd === 0)
         return 0;
@@ -93,51 +91,38 @@ const _calculateDepthBandsPriceImpact = (tradeSizeUsd, depthBandParams) => {
         const bandLiquidityPercentageBps = depthBandParams.depthBands.bands[i]; // Already in 0-1 format
         const topOfBandOffsetPpm = depthBandParams.depthBandsMapping.bands[i]; // Already in 0-1 format
         const bandDepthUsd = bandLiquidityPercentageBps * totalDepthUsd;
-        console.log("bandDepthUsd", bandDepthUsd);
         // Skip if band has same depth as previous (would cause division by zero)
         if (bandDepthUsd <= prevBandDepthUsd) {
-            console.log("Skipping band");
             prevBandDepthUsd = bandDepthUsd;
             topOfPrevBandOffsetPpm = topOfBandOffsetPpm;
             continue;
         }
         // Since bandDepthUsd represents liquidity from mid price to top of band, we need to subtract previous band depth
         const bandAvailableDepthUsd = bandDepthUsd - prevBandDepthUsd;
-        console.log("bandAvailableDepthUsd", bandAvailableDepthUsd);
         let depthConsumedUsd;
         // At 100% band always consume all remaining size, even if more than band available depth
         if (bandLiquidityPercentageBps === 1 ||
             remainingSizeUsd <= bandAvailableDepthUsd) {
             depthConsumedUsd = remainingSizeUsd;
             remainingSizeUsd = 0;
-            console.log("Consumed all remaining size");
         }
         else {
             // Normal case: consume entire band and continue to next
             depthConsumedUsd = bandAvailableDepthUsd;
             remainingSizeUsd -= bandAvailableDepthUsd;
-            console.log("Consumed entire band");
         }
         // Calculate impact contribution from this band using trapezoidal rule
         // Low = previous band's price offset, High = current band's price offset
         const lowOffsetP = topOfPrevBandOffsetPpm;
         const offsetRangeP = topOfBandOffsetPpm - topOfPrevBandOffsetPpm;
-        console.log("lowOffsetP", lowOffsetP);
-        console.log("offsetRangeP", offsetRangeP);
-        console.log("depthConsumedUsd", depthConsumedUsd);
-        console.log("bandAvailableDepthUsd", bandAvailableDepthUsd);
         // Calculate average impact using trapezoidal rule: low + (range * fraction / 2)
         const avgImpactP = lowOffsetP +
             (offsetRangeP * depthConsumedUsd) / bandAvailableDepthUsd / 2;
-        console.log("avgImpactP", avgImpactP);
         totalWeightedPriceImpactP += avgImpactP * depthConsumedUsd;
-        console.log("totalWeightedPriceImpactP", totalWeightedPriceImpactP);
         // Update previous values for next iteration
         topOfPrevBandOffsetPpm = topOfBandOffsetPpm;
         prevBandDepthUsd = bandDepthUsd;
     }
-    console.log("totalWeightedPriceImpactP", totalWeightedPriceImpactP);
-    console.log("tradeSizeUsd", tradeSizeUsd);
     return totalWeightedPriceImpactP / tradeSizeUsd;
 };
 /**
@@ -164,12 +149,8 @@ const _getDepthBandsPriceImpactP = (cumulativeVolumeUsd, tradeSizeUsd, depthBand
     const totalSizeLookupUsdUint = isNegative
         ? -totalSizeLookupUsd
         : totalSizeLookupUsd;
-    console.log("effectiveCumulativeVolumeUsdUint", effectiveCumulativeVolumeUsdUint);
-    console.log("totalSizeLookupUsdUint", totalSizeLookupUsdUint);
     const cumulativeVolPriceImpactP = _calculateDepthBandsPriceImpact(effectiveCumulativeVolumeUsdUint, depthBandParams);
     const totalSizePriceImpactP = _calculateDepthBandsPriceImpact(totalSizeLookupUsdUint, depthBandParams);
-    console.log("cumulativeVolPriceImpactP", cumulativeVolPriceImpactP);
-    console.log("totalSizePriceImpactP", totalSizePriceImpactP);
     const unscaledPriceImpactP = cumulativeVolPriceImpactP +
         (totalSizePriceImpactP - cumulativeVolPriceImpactP) / 2;
     const scaledPriceImpactP = unscaledPriceImpactP * priceImpactFactor;
@@ -208,15 +189,11 @@ long, tradeOpenInterestUsd, isPnlPositive, open, lastPosIncreaseBlock, context)
         (!open &&
             context?.exemptAfterProtectionCloseFactor === true &&
             (0, exports.isProtectionCloseFactorActive)(updatedContext) !== true)) {
-        console.log("No price impact, protection close factor");
         return 0;
     }
     const tradePositiveSkew = (long && open) || (!long && !open);
     const tradeSkewMultiplier = tradePositiveSkew ? 1 : -1;
-    console.log("bands", context.pairDepthBands);
-    console.log("mapping", context.depthBandsMapping);
     if (!context.pairDepthBands || !context.depthBandsMapping) {
-        console.log("No price impact, bands");
         return 0;
     }
     // Select depth bands based on trade direction
@@ -225,7 +202,6 @@ long, tradeOpenInterestUsd, isPnlPositive, open, lastPosIncreaseBlock, context)
         : context.pairDepthBands.below;
     // Return 0 if no depth bands configured (matching contract lines 588-590)
     if (!depthBands || depthBands.totalDepthUsd === 0) {
-        console.log("No price impact, depth bands");
         return 0;
     }
     // Get active OI for cumulative volume calculation
@@ -234,11 +210,8 @@ long, tradeOpenInterestUsd, isPnlPositive, open, lastPosIncreaseBlock, context)
         activeOi =
             (0, oiWindows_1.getActiveOi)((0, oiWindows_1.getCurrentOiWindowId)(context.oiWindowsSettings), context.oiWindowsSettings.windowsCount, context.oiWindows, open ? long : !long) || 0;
     }
-    console.log("activeOi", activeOi);
     const signedActiveOi = activeOi * tradeSkewMultiplier;
     const signedTradeOi = tradeOpenInterestUsd * tradeSkewMultiplier;
-    console.log("signedActiveOi", signedActiveOi);
-    console.log("signedTradeOi", signedTradeOi);
     // Calculate price impact using depth bands
     const priceImpactP = _getDepthBandsPriceImpactP(signedActiveOi, signedTradeOi, {
         depthBands: depthBands,

package/lib/trade/priceImpact/open/index.js

@@ -23,17 +23,14 @@ const getTradeOpeningPriceImpact = (input, context) => {
     // Calculate fixed spread
     const spreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.long, true // opening
     );
-    console.log("spreadP", spreadP);
     // Calculate position size in USD
     const positionSizeUsd = positionSizeCollateral * context.collateralPriceUsd;
-    console.log("positionSizeUsd", positionSizeUsd);
     // Calculate cumulative volume price impact
     const cumulVolPriceImpactP = (0, cumulVol_1.getTradeCumulVolPriceImpactP)("", // trader - not needed for calculation
     input.pairIndex, input.long, positionSizeUsd, false, // isPnlPositive - not relevant for opening
     true, // open
     0, // lastPosIncreaseBlock - not relevant for opening
     context.cumulVolContext);
-    console.log("cumulVolPriceImpactP", cumulVolPriceImpactP);
     // Calculate price after spread and cumulative volume impact (before skew)
     const priceAfterSpreadAndCumulVolPriceImpact = (0, __1.getPriceAfterImpact)(input.openPrice, spreadP + cumulVolPriceImpactP);
     // Calculate position size in tokens using the price after fixed spread and cumul vol impact

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "1.5.0-rc2",
+  "version": "1.5.0-rc4",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [