@gainsnetwork/sdk 0.0.0-v10.rc22 → 0.0.0-v10.rc23

package/lib/markets/price/marketPrice.d.ts

@@ -4,6 +4,7 @@
 import { MarketPriceResult, MarketPriceContext } from "./types";
 /**
  * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
  * @param pairIndex Trading pair index
  * @param oraclePrice Oracle price for the pair
  * @param context Market price context with depths and OI data

package/lib/markets/price/marketPrice.js

@@ -7,6 +7,7 @@ exports.getCurrentMarketPrice = void 0;
 const skew_1 = require("../../trade/priceImpact/skew");
 /**
  * @dev Calculates the current market price adjusted for skew impact
+ * @dev Please always provide oracle price to this and other functions in the sdk. Market price is displayed in the UI.
  * @param pairIndex Trading pair index
  * @param oraclePrice Oracle price for the pair
  * @param context Market price context with depths and OI data
@@ -22,7 +23,7 @@ const getCurrentMarketPrice = (pairIndex, oraclePrice, context) => {
             open: true,
             positionSizeToken: 0, // Size 0 for current market price
         }, context);
-        skewImpactP = skewResult.priceImpactP;
+        skewImpactP = skewResult.basePriceImpactP;
     }
     const marketPrice = oraclePrice * (1 + skewImpactP / 100);
     return {

package/lib/trade/liquidation/index.d.ts

@@ -10,6 +10,19 @@ import { GetLiquidationPriceContext } from "./types";
  * @returns Liquidation price
  */
 export declare const getLiquidationPrice: (trade: Trade, context: GetLiquidationPriceContext) => number;
+/**
+ * @dev Calculate liquidation price after a position size update
+ * @dev Mirrors the contract's IncreasePositionSizeUtils.sol and DecreasePositionSizeUtils.sol logic
+ * @param existingTrade The current trade before the update
+ * @param newCollateralAmount New collateral amount after the update
+ * @param newLeverage New leverage after the update
+ * @param isLeverageUpdate Whether this is a leverage update vs regular position change
+ * @param positionSizeCollateralDelta The absolute change in position size (in collateral terms)
+ * @param pnlToRealizeCollateral PnL to be realized (only relevant for leverage decrease)
+ * @param context Structured context with all required data (including additionalFeesCollateral for increases)
+ * @returns New liquidation price after the update
+ */
+export declare const getLiquidationPriceAfterPositionUpdate: (existingTrade: Trade, newCollateralAmount: number, newLeverage: number, isLeverageUpdate: boolean, positionSizeCollateralDelta: number, pnlToRealizeCollateral: number, context: GetLiquidationPriceContext) => number;
 export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;
 export { convertLiquidationParams, convertLiquidationParamsArray, encodeLiquidationParams, } from "./converter";
 export * from "./types";

package/lib/trade/liquidation/index.js

@@ -17,7 +17,7 @@ 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.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
+exports.encodeLiquidationParams = exports.convertLiquidationParamsArray = exports.convertLiquidationParams = exports.getLiqPnlThresholdP = exports.getLiquidationPriceAfterPositionUpdate = exports.getLiquidationPrice = void 0;
 const types_1 = require("../../contracts/types");
 const __1 = require("..");
 /**
@@ -86,6 +86,101 @@ const getLiquidationPrice = (trade, context) => {
         : Math.max(trade.openPrice + liqPriceDistance, 0);
 };
 exports.getLiquidationPrice = getLiquidationPrice;
+/**
+ * @dev Calculate liquidation price after a position size update
+ * @dev Mirrors the contract's IncreasePositionSizeUtils.sol and DecreasePositionSizeUtils.sol logic
+ * @param existingTrade The current trade before the update
+ * @param newCollateralAmount New collateral amount after the update
+ * @param newLeverage New leverage after the update
+ * @param isLeverageUpdate Whether this is a leverage update vs regular position change
+ * @param positionSizeCollateralDelta The absolute change in position size (in collateral terms)
+ * @param pnlToRealizeCollateral PnL to be realized (only relevant for leverage decrease)
+ * @param context Structured context with all required data (including additionalFeesCollateral for increases)
+ * @returns New liquidation price after the update
+ */
+const getLiquidationPriceAfterPositionUpdate = (existingTrade, newCollateralAmount, newLeverage, isLeverageUpdate, positionSizeCollateralDelta, pnlToRealizeCollateral, context) => {
+    var _a, _b;
+    const { currentPairPrice, isCounterTrade = false } = context.liquidationSpecific;
+    // 1. Calculate closing fees on the NEW position size
+    const closingFeeCollateral = (0, __1.getTotalTradeFeesCollateral)(existingTrade.collateralIndex, "", // No fee tiers applied for liquidation calculation
+    existingTrade.pairIndex, newCollateralAmount * newLeverage, isCounterTrade, {
+        fee: context.trading.fee,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        globalTradeFeeParams: context.trading.globalTradeFeeParams,
+        traderFeeMultiplier: 1,
+        counterTradeSettings: context.trading.counterTradeSettings,
+    });
+    // 2. Calculate holding fees on the EXISTING trade (full position)
+    const holdingFees = (0, __1.getTradePendingHoldingFeesCollateral)(existingTrade, context.tradeData.tradeInfo, context.tradeData.tradeFeesData, currentPairPrice, {
+        contractsVersion: context.core.contractsVersion,
+        currentTimestamp: context.core.currentTimestamp,
+        collateralPriceUsd: context.core.collateralPriceUsd,
+        borrowingV1: context.borrowingV1,
+        borrowingV2: context.borrowingV2,
+        funding: context.funding,
+        initialAccFees: context.tradeData.initialAccFees,
+    });
+    // 3. Calculate total realized PnL
+    const totalRealizedPnlCollateral = context.tradeData.tradeFeesData.realizedPnlCollateral -
+        context.tradeData.tradeFeesData.realizedTradingFeesCollateral;
+    // 4. Determine if this is an increase or decrease
+    const existingPositionSizeCollateral = existingTrade.collateralAmount * existingTrade.leverage;
+    const newPositionSizeCollateral = newCollateralAmount * newLeverage;
+    const isIncrease = newPositionSizeCollateral > existingPositionSizeCollateral;
+    // 5. Calculate additional fee and partial close multiplier based on update type
+    let additionalFeeCollateral;
+    let partialCloseMultiplier;
+    if (isIncrease) {
+        // For position increases: use additional fees from context (e.g., opening fees), no partial close
+        additionalFeeCollateral =
+            context.liquidationSpecific.additionalFeeCollateral || 0;
+        partialCloseMultiplier = 0; // Not a partial close
+    }
+    else if (isLeverageUpdate) {
+        // For leverage decreases: additional fee includes closing fee minus PnL to realize
+        additionalFeeCollateral = closingFeeCollateral - pnlToRealizeCollateral;
+        partialCloseMultiplier = 1; // Full multiplier for leverage updates
+    }
+    else {
+        // For regular position decreases: no additional fee, scaled multiplier
+        additionalFeeCollateral = 0;
+        partialCloseMultiplier =
+            (existingPositionSizeCollateral - positionSizeCollateralDelta) /
+                existingPositionSizeCollateral;
+    }
+    // 6. Calculate total fees
+    const totalFeesCollateral = closingFeeCollateral +
+        (holdingFees.totalFeeCollateral - totalRealizedPnlCollateral) *
+            partialCloseMultiplier +
+        additionalFeeCollateral;
+    // 7. Calculate liquidation threshold
+    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.tradeData.liquidationParams, newLeverage);
+    // 8. Calculate liquidation price distance
+    const collateralLiqNegativePnl = newCollateralAmount * liqThresholdP;
+    // For increases, we need to use the new weighted average open price
+    // For decreases, we use the existing open price
+    const openPriceToUse = isIncrease
+        ? context.liquidationSpecific.newOpenPrice || existingTrade.openPrice
+        : existingTrade.openPrice;
+    let liqPriceDistance = (openPriceToUse * (collateralLiqNegativePnl - totalFeesCollateral)) /
+        newCollateralAmount /
+        newLeverage;
+    // 9. Apply closing spread for v9.2+
+    if (context.core.contractsVersion >= types_1.ContractsVersion.V9_2 &&
+        ((((_a = context.tradeData.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
+            context.tradeData.liquidationParams.maxLiqSpreadP > 0) ||
+            (((_b = context.liquidationSpecific.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !==
+                undefined &&
+                context.liquidationSpecific.userPriceImpact.fixedSpreadP > 0))) {
+        const closingSpreadP = (0, __1.getSpreadP)(context.core.spreadP, true, context.tradeData.liquidationParams, context.liquidationSpecific.userPriceImpact);
+        liqPriceDistance -= openPriceToUse * closingSpreadP;
+    }
+    // 10. Calculate final liquidation price
+    return existingTrade.long
+        ? Math.max(openPriceToUse - liqPriceDistance, 0)
+        : Math.max(openPriceToUse + liqPriceDistance, 0);
+};
+exports.getLiquidationPriceAfterPositionUpdate = getLiquidationPriceAfterPositionUpdate;
 const getLiqPnlThresholdP = (liquidationParams, leverage) => {
     if (liquidationParams === undefined ||
         leverage === undefined ||

package/lib/trade/liquidation/types.d.ts

@@ -38,5 +38,6 @@ export type GetLiquidationPriceContext = {
         beforeOpened: boolean;
         isCounterTrade: boolean;
         userPriceImpact?: UserPriceImpact;
+        newOpenPrice?: number;
     };
 };

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

@@ -43,8 +43,11 @@ const getTradeClosingPriceImpact = (input, context) => {
             positionSizeToken: 0,
             fixedSpreadP: 0,
             cumulVolPriceImpactP: 0,
-            skewPriceImpactP: 0,
+            baseSkewPriceImpactP: 0,
+            tradeSkewPriceImpactP: 0,
+            totalSkewPriceImpactP: 0,
             totalPriceImpactP: 0,
+            totalPriceImpactPFromMarketPrice: 0,
             priceAfterImpact: input.oraclePrice,
             tradeValueCollateralNoFactor: 0,
         };
@@ -83,25 +86,37 @@ const getTradeClosingPriceImpact = (input, context) => {
         }
     }
     // Calculate skew price impact (v10+ only)
-    const skewPriceImpactP = input.contractsVersion >= types_1.ContractsVersion.V10
+    const skewPriceImpactObject = input.contractsVersion >= types_1.ContractsVersion.V10
         ? (0, skew_1.getTradeSkewPriceImpact)({
             collateralIndex: input.collateralIndex,
             pairIndex: input.pairIndex,
             long: input.trade.long,
             open: false,
             positionSizeToken,
-        }, context.skewContext).priceImpactP
-        : 0;
+        }, context.skewContext)
+        : {
+            basePriceImpactP: 0,
+            tradePriceImpactP: 0,
+            totalPriceImpactP: 0,
+        };
     // Total price impact (all components)
-    const totalPriceImpactP = fixedSpreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    const totalPriceImpactP = fixedSpreadP +
+        cumulVolPriceImpactP +
+        skewPriceImpactObject.totalPriceImpactP;
+    const totalPriceImpactPFromMarketPrice = fixedSpreadP +
+        cumulVolPriceImpactP +
+        skewPriceImpactObject.tradePriceImpactP;
     // Calculate final price after all impacts
     const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.currentPairPrice, totalPriceImpactP);
     return {
         positionSizeToken,
         fixedSpreadP,
         cumulVolPriceImpactP,
-        skewPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
         totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
         priceAfterImpact,
         tradeValueCollateralNoFactor,
     };

package/lib/trade/priceImpact/close/types.d.ts

@@ -37,8 +37,11 @@ export type TradeClosingPriceImpactResult = {
     positionSizeToken: number;
     fixedSpreadP: number;
     cumulVolPriceImpactP: number;
-    skewPriceImpactP: number;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
     totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: number;
     priceAfterImpact: number;
     tradeValueCollateralNoFactor: number;
 };

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

@@ -36,16 +36,17 @@ const getTradeOpeningPriceImpact = (input, context) => {
     // Calculate position size in tokens using the price after fixed spread and cumul vol impact
     const positionSizeToken = positionSizeCollateral / priceAfterSpreadAndCumulVolPriceImpact;
     // Calculate skew price impact (v10+ only)
-    const skewResult = (0, skew_1.getTradeSkewPriceImpact)({
+    const skewPriceImpactObject = (0, skew_1.getTradeSkewPriceImpact)({
         collateralIndex: input.collateralIndex,
         pairIndex: input.pairIndex,
         long: input.long,
         open: true,
         positionSizeToken,
     }, context.skewContext);
-    const skewPriceImpactP = skewResult.priceImpactP;
+    const skewPriceImpactP = skewPriceImpactObject.totalPriceImpactP;
     // Total price impact (signed - can be positive or negative)
     const totalPriceImpactP = spreadP + cumulVolPriceImpactP + skewPriceImpactP;
+    const totalPriceImpactPFromMarketPrice = spreadP + cumulVolPriceImpactP + skewPriceImpactObject.tradePriceImpactP;
     // Calculate final price after impact using the same formula as Solidity
     const priceAfterImpact = (0, __1.getPriceAfterImpact)(input.openPrice, totalPriceImpactP);
     // Calculate percent profit from impact
@@ -56,8 +57,11 @@ const getTradeOpeningPriceImpact = (input, context) => {
         priceAfterImpact,
         percentProfitP,
         cumulVolPriceImpactP,
-        skewPriceImpactP,
+        baseSkewPriceImpactP: skewPriceImpactObject.basePriceImpactP,
+        tradeSkewPriceImpactP: skewPriceImpactObject.tradePriceImpactP,
+        totalSkewPriceImpactP: skewPriceImpactObject.totalPriceImpactP,
         totalPriceImpactP,
+        totalPriceImpactPFromMarketPrice,
     };
 };
 exports.getTradeOpeningPriceImpact = getTradeOpeningPriceImpact;

package/lib/trade/priceImpact/open/types.d.ts

@@ -36,6 +36,9 @@ export type TradeOpeningPriceImpactResult = {
     priceAfterImpact: number;
     percentProfitP: number;
     cumulVolPriceImpactP: number;
-    skewPriceImpactP: number;
+    baseSkewPriceImpactP: number;
+    tradeSkewPriceImpactP: number;
+    totalSkewPriceImpactP: number;
     totalPriceImpactP: number;
+    totalPriceImpactPFromMarketPrice: number;
 };

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

@@ -101,20 +101,25 @@ const getTradeSkewPriceImpact = (input, context) => {
     // Determine trade direction
     const tradePositiveSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
     // Calculate price impact
-    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradePositiveSkew);
+    const basePriceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, 0, skewDepth, tradePositiveSkew);
+    // Calculate price impact
+    const totalPriceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradePositiveSkew);
+    const tradePriceImpactP = totalPriceImpactP - basePriceImpactP;
     // Determine trade direction relative to skew
     let tradeDirection;
-    if (priceImpactP > 0) {
+    if (totalPriceImpactP > 0) {
         tradeDirection = "increase";
     }
-    else if (priceImpactP < 0) {
+    else if (totalPriceImpactP < 0) {
         tradeDirection = "decrease";
     }
     else {
         tradeDirection = "neutral";
     }
     return {
-        priceImpactP,
+        basePriceImpactP,
+        tradePriceImpactP,
+        totalPriceImpactP,
         netSkewToken,
         netSkewCollateral: 0,
         tradeDirection,

package/lib/trade/priceImpact/skew/types.d.ts

@@ -17,7 +17,9 @@ export type SkewPriceImpactInput = {
     positionSizeToken: number;
 };
 export type SkewPriceImpactResult = {
-    priceImpactP: number;
+    basePriceImpactP: number;
+    tradePriceImpactP: number;
+    totalPriceImpactP: number;
     netSkewToken: number;
     netSkewCollateral: number;
     tradeDirection: "increase" | "decrease" | "neutral";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.0.0-v10.rc22",
+  "version": "0.0.0-v10.rc23",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [