@gainsnetwork/sdk 0.2.12-rc3 → 0.2.12

package/lib/contracts/utils/openLimitOrders.d.ts

@@ -0,0 +1,8 @@
+import { LimitOrder } from "../../trade/types";
+import { BlockTag, Contracts } from "../types";
+export type FetchOpenLimitOrdersOverrides = {
+    blockTag?: BlockTag;
+    useMulticall?: boolean;
+};
+export declare const fetchOpenLimitOrders: (contracts: Contracts, overrides?: FetchOpenLimitOrdersOverrides) => Promise<LimitOrder[]>;
+export declare const fetchOpenLimitOrdersRaw: (contracts: Contracts, overrides?: FetchOpenLimitOrdersOverrides) => Promise<any[]>;

package/lib/contracts/utils/openLimitOrders.js

@@ -0,0 +1,88 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+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.fetchOpenLimitOrdersRaw = exports.fetchOpenLimitOrders = void 0;
+const ethcall_1 = require("ethcall");
+const fetchOpenLimitOrders = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const openLimitOrdersRaw = yield (0, exports.fetchOpenLimitOrdersRaw)(contracts, overrides);
+    return openLimitOrdersRaw.map((order) => ({
+        block: parseInt(order.block.toString()),
+        buy: order.buy,
+        index: parseInt(order.index.toString()),
+        leverage: parseInt(order.leverage.toString()),
+        maxPrice: parseFloat(order.maxPrice.toString()) / 1e10,
+        minPrice: parseFloat(order.minPrice.toString()) / 1e10,
+        pairIndex: parseInt(order.pairIndex.toString()),
+        positionSize: parseFloat(order.positionSize.toString()) / 1e18,
+        sl: parseFloat(order.sl.toString()) / 1e10,
+        spreadReductionP: parseInt(order.spreadReductionP.toString()) / 100,
+        tp: parseFloat(order.tp.toString()) / 1e10,
+        trader: order.trader,
+        type: parseInt(order.type.toString()),
+        maxSlippageP: parseFloat(order.maxSlippageP.toString()) / 1e10,
+    }));
+});
+exports.fetchOpenLimitOrders = fetchOpenLimitOrders;
+const fetchOpenLimitOrdersRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    console.time("fetchOpenLimitOrdersRaw");
+    const { useMulticall = false, blockTag = "latest" } = overrides;
+    const { gfarmTradingStorageV5: storageContract, gnsNftRewards: nftRewards, gnsTradingCallbacks: callbacks, } = contracts;
+    const openLimitOrders = yield storageContract.getOpenLimitOrders({
+        blockTag,
+    });
+    let openLimitOrderTypes = [];
+    let openLimitOrderTradeData = [];
+    if (useMulticall) {
+        const multicallProvider = new ethcall_1.Provider();
+        yield multicallProvider.init(storageContract.provider);
+        const nftRewardsContractMulticall = new ethcall_1.Contract(nftRewards.address, [
+            ...nftRewards.interface.fragments,
+        ]);
+        const callbacksContractMulticall = new ethcall_1.Contract(callbacks.address, [
+            ...callbacks.interface.fragments,
+        ]);
+        openLimitOrderTypes = yield multicallProvider.all(openLimitOrders.map(order => nftRewardsContractMulticall.openLimitOrderTypes(order.trader, order.pairIndex, order.index)), blockTag);
+        openLimitOrderTradeData = yield multicallProvider.all(openLimitOrders.map(order => callbacksContractMulticall.tradeData(order.trader, order.pairIndex, order.index, 1)), blockTag);
+    }
+    else {
+        openLimitOrderTypes = yield Promise.all(openLimitOrders.map(order => nftRewards.openLimitOrderTypes(order.trader, order.pairIndex, order.index, { blockTag })));
+        openLimitOrderTradeData = yield Promise.all(openLimitOrders.map(order => callbacks.tradeData(order.trader, order.pairIndex, order.index, 1, {
+            blockTag,
+        })));
+    }
+    return openLimitOrderTypes.map((openLimitOrderType, index) => {
+        const openLimitOrder = openLimitOrders[index];
+        const tradeData = openLimitOrderTradeData[index];
+        return {
+            trader: openLimitOrder.trader,
+            pairIndex: openLimitOrder.pairIndex,
+            index: openLimitOrder.index,
+            positionSize: openLimitOrder.positionSize,
+            spreadReductionP: openLimitOrder.spreadReductionP,
+            buy: openLimitOrder.buy,
+            leverage: openLimitOrder.leverage,
+            tp: openLimitOrder.tp,
+            sl: openLimitOrder.sl,
+            minPrice: openLimitOrder.minPrice,
+            maxPrice: openLimitOrder.maxPrice,
+            block: openLimitOrder.block,
+            type: openLimitOrderType,
+            maxSlippageP: tradeData.maxSlippageP,
+        };
+    });
+});
+exports.fetchOpenLimitOrdersRaw = fetchOpenLimitOrdersRaw;

package/lib/contracts/utils/openTrades.js

@@ -14,7 +14,7 @@ const ethcall_1 = require("ethcall");
 const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
     const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
     const collateralPrecisions = (yield contracts.gnsMultiCollatDiamond.getCollaterals()).map(({ precision }) => precision);
-    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
+    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.initialAccFees, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
 });
 exports.fetchOpenPairTrades = fetchOpenPairTrades;
 // @todo rename
@@ -40,7 +40,6 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
         while (running) {
             const trades = yield multiCollatDiamondContract.getAllTrades(offset, offset + batchSize);
             const tradeInfos = yield multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize);
-            const tradeLiquidationParams = yield multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize);
             // Array is always of length `batchSize`
             // so we need to filter out the empty trades, indexes are reliable
             const openTrades = trades
@@ -49,7 +48,6 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                 .map((trade, ix) => ({
                 trade,
                 tradeInfo: tradeInfos[ix],
-                liquidationParams: tradeLiquidationParams[ix],
                 initialAccFees: {
                     accPairFee: 0,
                     accGroupFee: 0,
@@ -85,7 +83,7 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     }
 });
 exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
-const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, collateralPrecision) => ({
+const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, collateralPrecision) => ({
     trade: {
         user: trade.user,
         index: parseInt(trade.index.toString()),
@@ -109,13 +107,6 @@ const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeI
         lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
         collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
     },
-    liquidationParams: {
-        maxLiqSpreadP: parseFloat(tradeLiquidationParams.maxLiqSpreadP.toString()) / 1e10,
-        startLiqThresholdP: parseFloat(tradeLiquidationParams.startLiqThresholdP.toString()) / 1e10,
-        endLiqThresholdP: parseFloat(tradeLiquidationParams.endLiqThresholdP.toString()) / 1e10,
-        startLeverage: parseFloat(tradeLiquidationParams.startLeverage.toString()) / 1e3,
-        endLeverage: parseFloat(tradeLiquidationParams.endLeverage.toString()) / 1e3,
-    },
     initialAccFees: {
         accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
         accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,

package/lib/contracts/utils/pairs.d.ts

@@ -2,7 +2,6 @@ import { Pair, Fee, OpenInterest, PairDepth, PairIndex } from "../../trade/types
 import { Contracts } from "../../contracts/types";
 export declare const fetchPairs: (contracts: Contracts, pairIxs: PairIndex[]) => Promise<Pair[]>;
 export declare const fetchPairDepths: (contracts: Contracts, pairIxs: number[]) => Promise<PairDepth[]>;
-export declare const fetchProtectionCloseFactors: (contracts: Contracts, pairIxs: number[]) => Promise<number[]>;
 export declare const fetchFees: (contracts: Contracts, feeIxs: PairIndex[]) => Promise<Fee[]>;
 export declare const fetchOpenInterest: (contracts: Contracts, collateralIndex: number, pairIxs: number[]) => Promise<OpenInterest[]>;
 export declare const getPairDescription: (pairIndex: PairIndex) => string;

package/lib/contracts/utils/pairs.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchProtectionCloseFactors = exports.fetchPairDepths = exports.fetchPairs = void 0;
+exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchPairDepths = exports.fetchPairs = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
@@ -60,23 +60,6 @@ const fetchPairDepths = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0
     }
 });
 exports.fetchPairDepths = fetchPairDepths;
-const fetchProtectionCloseFactors = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!contracts) {
-        return [];
-    }
-    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
-    try {
-        const protectionCloseFactors = yield multiCollatContract.getProtectionCloseFactors(pairIxs);
-        return protectionCloseFactors.map(protectionCloseFactor => {
-            return protectionCloseFactor.toNumber();
-        });
-    }
-    catch (error) {
-        console.error(`Unexpected error while fetching pairs!`);
-        throw error;
-    }
-});
-exports.fetchProtectionCloseFactors = fetchProtectionCloseFactors;
 const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, function* () {
     if (!contracts) {
         return [];

package/lib/markets/forex.js

@@ -36,8 +36,8 @@ const isForexLowLiquidity = (timestampToCheck, pair) => {
     const groupIndex = pair === null || pair === void 0 ? void 0 : pair.groupIndex;
     if (groupIndex && extendedLowLiqGroupIds.includes(+groupIndex)) {
         return ((isInDST &&
-            ((hour == 15 && minute >= 15) || (hour >= 16 && hour < 21))) ||
-            (!isInDST && ((hour == 16 && minute >= 15) || (hour >= 17 && hour < 22))));
+            ((hour == 14 && minute >= 45) || (hour >= 16 && hour < 21))) ||
+            (!isInDST && ((hour == 15 && minute >= 45) || (hour >= 17 && hour < 22))));
     }
     return ((isInDST && ((hour == 15 && minute >= 45) || (hour >= 16 && hour < 19))) ||
         (!isInDST && ((hour == 16 && minute >= 45) || (hour >= 17 && hour < 20))));

package/lib/trade/liquidation.d.ts

@@ -1,8 +1,3 @@
 import { GetBorrowingFeeContext, BorrowingFee } from "./fees";
-import { Fee, LiquidationParams, Trade } from "./types";
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & {
-    liquidationParams: LiquidationParams | undefined;
-    pairSpreadP: number | undefined;
-};
-export declare const getLiquidationPrice: (trade: Trade, fee: Fee, initialAccFees: BorrowingFee.InitialAccFees, context: GetLiquidationPriceContext) => number;
-export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;
+import { Fee, Trade } from "./types";
+export declare const getLiquidationPrice: (trade: Trade, fee: Fee, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;

package/lib/trade/liquidation.js

@@ -1,47 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
+exports.getLiquidationPrice = void 0;
 const fees_1 = require("./fees");
-const spread_1 = require("./spread");
 const getLiquidationPrice = (trade, fee, initialAccFees, context) => {
-    var _a;
     const closingFee = (0, fees_1.getClosingFee)(trade.collateralAmount, trade.leverage, trade.pairIndex, fee);
     const borrowingFee = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
-    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage);
-    let liqPriceDistance = (trade.openPrice *
-        (trade.collateralAmount * liqThresholdP - (borrowingFee + closingFee))) /
+    const liqPriceDistance = (trade.openPrice *
+        (trade.collateralAmount * 0.9 - (borrowingFee + closingFee))) /
         trade.collateralAmount /
         trade.leverage;
-    if (((_a = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
-        context.liquidationParams.maxLiqSpreadP > 0) {
-        const closingSpreadP = (0, spread_1.getSpreadP)(context.pairSpreadP, true, context.liquidationParams);
-        liqPriceDistance += trade.openPrice * closingSpreadP;
-    }
     return trade.long
         ? Math.max(trade.openPrice - liqPriceDistance, 0)
         : Math.max(trade.openPrice + liqPriceDistance, 0);
 };
 exports.getLiquidationPrice = getLiquidationPrice;
-const getLiqPnlThresholdP = (liquidationParams, leverage) => {
-    if (liquidationParams === undefined ||
-        leverage === undefined ||
-        liquidationParams.maxLiqSpreadP === 0 ||
-        liquidationParams.startLiqThresholdP === 0 ||
-        liquidationParams.endLiqThresholdP === 0 ||
-        liquidationParams.startLeverage === 0 ||
-        liquidationParams.endLeverage === 0) {
-        return 0.9;
-    }
-    if (leverage < liquidationParams.startLeverage) {
-        return liquidationParams.startLiqThresholdP;
-    }
-    if (leverage > liquidationParams.endLeverage) {
-        return liquidationParams.endLiqThresholdP;
-    }
-    return (liquidationParams.startLiqThresholdP -
-        ((leverage - liquidationParams.startLeverage) *
-            (liquidationParams.startLiqThresholdP -
-                liquidationParams.endLiqThresholdP)) /
-            (liquidationParams.endLeverage - liquidationParams.startLeverage));
-};
-exports.getLiqPnlThresholdP = getLiqPnlThresholdP;

package/lib/trade/openLimitOrder.d.ts

@@ -0,0 +1,2 @@
+import { LimitOrder, Pair, PairDepth, OiWindowsSettings, OiWindows } from "./types";
+export declare const getFulfillmentPrice: (order: LimitOrder, pair: Pair, pairDepth: PairDepth, oiWindowsSettings?: OiWindowsSettings, oiWindows?: OiWindows) => number;

package/lib/trade/openLimitOrder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFulfillmentPrice = void 0;
+const spread_1 = require("./spread");
+const types_1 = require("./types");
+const getFulfillmentPrice = (order, pair, pairDepth, oiWindowsSettings, oiWindows) => {
+    if (!order || !pair) {
+        return 0;
+    }
+    // Get spread percentage
+    const spreadWithPriceImpactP = (0, spread_1.getSpreadWithPriceImpactP)(pair.spreadP, order.buy, order.positionSize, order.leverage, pairDepth, oiWindowsSettings, oiWindows);
+    if (spreadWithPriceImpactP === 0) {
+        return 0;
+    }
+    const askingPrice = (order.buy && order.type === types_1.OpenLimitOrderType.REVERSAL) ||
+        (!order.buy && order.type === types_1.OpenLimitOrderType.MOMENTUM)
+        ? order.maxPrice
+        : order.minPrice;
+    return order.buy
+        ? askingPrice * (1 + spreadWithPriceImpactP)
+        : askingPrice * (1 - spreadWithPriceImpactP);
+};
+exports.getFulfillmentPrice = getFulfillmentPrice;

package/lib/trade/pnl.d.ts

@@ -1,7 +1,7 @@
 import { GetBorrowingFeeContext } from "./fees";
-import { Fee, LiquidationParams, Trade, TradeInfo, TradeInitialAccFees } from "./types";
+import { Fee, Trade, TradeInfo, TradeInitialAccFees } from "./types";
 export type GetPnlContext = GetBorrowingFeeContext & {
     fee: Fee | undefined;
     maxGainP: number | undefined;
 };
-export declare const getPnl: (price: number | undefined, trade: Trade, tradeInfo: TradeInfo, initialAccFees: TradeInitialAccFees, liquidationParams: LiquidationParams, useFees: boolean, context: GetPnlContext) => number[] | undefined;
+export declare const getPnl: (price: number | undefined, trade: Trade, tradeInfo: TradeInfo, initialAccFees: TradeInitialAccFees, useFees: boolean, context: GetPnlContext) => number[] | undefined;

package/lib/trade/pnl.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPnl = void 0;
 const fees_1 = require("./fees");
-const liquidation_1 = require("./liquidation");
-const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
+const getPnl = (price, trade, tradeInfo, initialAccFees, useFees, context) => {
     if (!price) {
         return;
     }
@@ -20,8 +19,7 @@ const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useF
     }
     let pnlPercentage = (pnlCollat / posCollat) * 100;
     // Can be liquidated
-    if (pnlPercentage <=
-        (0, liquidation_1.getLiqPnlThresholdP)(liquidationParams, leverage) * -100) {
+    if (pnlPercentage <= -90) {
         pnlPercentage = -100;
     }
     else {

package/lib/trade/spread.d.ts

@@ -1,13 +1,2 @@
-import { LiquidationParams, OiWindows, OiWindowsSettings, PairDepth } from "./types";
-export type SpreadContext = {
-    isOpen?: boolean;
-    isPnlPositive?: boolean;
-    protectionCloseFactor?: number;
-    protectionCloseFactorBlocks?: number;
-    createdBlock?: number;
-    liquidationParams?: LiquidationParams | undefined;
-    currentBlock: number | undefined;
-};
-export declare const getProtectionCloseFactor: (spreadCtx: SpreadContext | undefined) => number;
-export declare const getSpreadWithPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, pairDepth: PairDepth | undefined, oiWindowsSettings?: OiWindowsSettings | undefined, oiWindows?: OiWindows | undefined, spreadCtx?: SpreadContext | undefined) => number;
-export declare const getSpreadP: (pairSpreadP: number | undefined, isLiquidation?: boolean | undefined, liquidationParams?: LiquidationParams | undefined) => number;
+import { OiWindows, OiWindowsSettings, PairDepth } from "./types";
+export declare const getSpreadWithPriceImpactP: (pairSpreadP: number, buy: boolean, collateral: number, leverage: number, pairDepth: PairDepth | undefined, oiWindowsSettings?: OiWindowsSettings | undefined, oiWindows?: OiWindows | undefined) => number;

package/lib/trade/spread.js

@@ -1,68 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSpreadP = exports.getSpreadWithPriceImpactP = exports.getProtectionCloseFactor = void 0;
+exports.getSpreadWithPriceImpactP = void 0;
 const oiWindows_1 = require("./oiWindows");
-const constants_1 = require("../constants");
-const getProtectionCloseFactor = (spreadCtx) => {
-    if (spreadCtx === undefined ||
-        spreadCtx.isOpen === undefined ||
-        spreadCtx.isPnlPositive === undefined ||
-        spreadCtx.protectionCloseFactor === undefined ||
-        spreadCtx.protectionCloseFactorBlocks === undefined ||
-        spreadCtx.createdBlock === undefined ||
-        spreadCtx.currentBlock === undefined)
-        return constants_1.DEFAULT_PROTECTION_CLOSE_FACTOR;
-    if (spreadCtx.isPnlPositive &&
-        !spreadCtx.isOpen &&
-        spreadCtx.protectionCloseFactor > 0 &&
-        spreadCtx.currentBlock <=
-            spreadCtx.createdBlock + spreadCtx.protectionCloseFactorBlocks) {
-        return spreadCtx.protectionCloseFactor;
-    }
-    return constants_1.DEFAULT_PROTECTION_CLOSE_FACTOR;
-};
-exports.getProtectionCloseFactor = getProtectionCloseFactor;
-const getSpreadWithPriceImpactP = (pairSpreadP, buy, collateral, leverage, pairDepth, oiWindowsSettings, oiWindows, spreadCtx) => {
+const getSpreadWithPriceImpactP = (pairSpreadP, buy, collateral, leverage, pairDepth, oiWindowsSettings, oiWindows) => {
     if (pairSpreadP === undefined) {
         return 0;
     }
-    // No spread or price impact when closing pre-v9.2 trades
-    if ((spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) === false &&
-        (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.liquidationParams) !== undefined &&
-        spreadCtx.liquidationParams.maxLiqSpreadP === 0) {
-        return 0;
-    }
     const onePercentDepth = buy
-        ? // if `long`
-            (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) !== false // assumes it's an open unless it's explicitly false
-                ? pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthAboveUsd
-                : pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthBelowUsd
-        : // if `short`
-            (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) !== false
-                ? pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthBelowUsd
-                : pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthAboveUsd;
+        ? pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthAboveUsd
+        : pairDepth === null || pairDepth === void 0 ? void 0 : pairDepth.onePercentDepthBelowUsd;
     let activeOi = undefined;
     if (oiWindowsSettings !== undefined && (oiWindowsSettings === null || oiWindowsSettings === void 0 ? void 0 : oiWindowsSettings.windowsCount) > 0) {
-        activeOi = (0, oiWindows_1.getActiveOi)((0, oiWindows_1.getCurrentOiWindowId)(oiWindowsSettings), oiWindowsSettings.windowsCount, oiWindows, (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) !== false ? buy : !buy);
+        activeOi = (0, oiWindows_1.getActiveOi)((0, oiWindows_1.getCurrentOiWindowId)(oiWindowsSettings), oiWindowsSettings.windowsCount, oiWindows, buy);
     }
     if (!onePercentDepth || activeOi === undefined || collateral === undefined) {
-        return pairSpreadP / 2;
+        return pairSpreadP;
     }
-    return ((0, exports.getSpreadP)(pairSpreadP) +
-        ((activeOi + (collateral * leverage) / 2) / onePercentDepth / 100 / 2) *
-            (0, exports.getProtectionCloseFactor)(spreadCtx));
+    return (pairSpreadP +
+        (activeOi + (collateral * leverage) / 2) / onePercentDepth / 100);
 };
 exports.getSpreadWithPriceImpactP = getSpreadWithPriceImpactP;
-const getSpreadP = (pairSpreadP, isLiquidation, liquidationParams) => {
-    if (pairSpreadP === undefined || pairSpreadP === 0) {
-        return 0;
-    }
-    const spreadP = pairSpreadP / 2;
-    return isLiquidation === true &&
-        liquidationParams !== undefined &&
-        liquidationParams.maxLiqSpreadP > 0 &&
-        spreadP > liquidationParams.maxLiqSpreadP
-        ? liquidationParams.maxLiqSpreadP
-        : spreadP;
-};
-exports.getSpreadP = getSpreadP;

package/lib/trade/types.d.ts

@@ -1,4 +1,4 @@
-import { ITradingStorage, IBorrowingFees, IPairsStorage } from "../contracts/types/generated/GNSMultiCollatDiamond";
+import { ITradingStorage, IBorrowingFees } from "../contracts/types/generated/GNSMultiCollatDiamond";
 import { BorrowingFee } from "./fees/borrowing";
 import { FeeTier, TraderInfo } from "./fees/tiers/types";
 export type PairIndexes = {
@@ -7,7 +7,6 @@ export type PairIndexes = {
 export type TradeContainer = {
     trade: Trade;
     tradeInfo: TradeInfo;
-    liquidationParams: LiquidationParams;
     initialAccFees: TradeInitialAccFees;
     receivedAt?: number;
 };
@@ -33,13 +32,6 @@ export type TradeInfo = {
     lastOiUpdateTs: number;
     collateralPriceUsd: number;
 };
-export type LiquidationParams = {
-    maxLiqSpreadP: number;
-    startLiqThresholdP: number;
-    endLiqThresholdP: number;
-    startLeverage: number;
-    endLeverage: number;
-};
 export type TradingGroup = {
     maxLeverage: number;
     minLeverage: number;
@@ -130,7 +122,6 @@ export declare enum PositionType {
 export type TradeContainerRaw = {
     trade: ITradingStorage.TradeStruct;
     tradeInfo: ITradingStorage.TradeInfoStruct;
-    liquidationParams: IPairsStorage.GroupLiquidationParamsStruct;
     initialAccFees: IBorrowingFees.BorrowingInitialAccFeesStruct;
 };
 export type OiWindowsSettings = {

package/package.json

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