@gainsnetwork/sdk 0.2.71-rc4 → 1.0.0-rc1

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

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * @dev Skew price impact calculations for v10+ trades
+ * @dev Based on formula: (existingSkew + tradeSize/2) / skewDepth
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkewPriceImpact = exports.calculatePartialSizeToken = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
+// Constants
+const PRICE_IMPACT_DIVIDER = 2; // Half price impact to match cumulative volume impact scale
+/**
+ * @dev Calculates net skew in tokens (long - short)
+ * @param pairOi Pair OI data with long and short token amounts
+ * @returns Net skew in tokens (positive = long heavy, negative = short heavy)
+ */
+const getNetSkewToken = (pairOi) => {
+    return pairOi.oiLongToken - pairOi.oiShortToken;
+};
+exports.getNetSkewToken = getNetSkewToken;
+/**
+ * @dev Calculates net skew in collateral
+ * @param netSkewToken Net skew in tokens
+ * @param currentPrice Current pair price
+ * @returns Net skew in collateral
+ */
+const getNetSkewCollateral = (netSkewToken, currentPrice) => {
+    return netSkewToken * currentPrice;
+};
+exports.getNetSkewCollateral = getNetSkewCollateral;
+/**
+ * @dev Determines trade direction impact on skew
+ * @param long Is long position
+ * @param open Is opening (true) or closing (false)
+ * @returns Whether trade increases or decreases skew
+ */
+const getTradeSkewDirection = (long, open) => {
+    // Opening long or closing short increases positive skew
+    // Opening short or closing long increases negative skew
+    return (long && open) || (!long && !open);
+};
+exports.getTradeSkewDirection = getTradeSkewDirection;
+/**
+ * @dev Core skew price impact calculation
+ * @param existingSkewToken Current net skew in tokens (signed)
+ * @param tradeSizeToken Trade size in tokens (always positive)
+ * @param skewDepth Skew depth in tokens
+ * @param tradePositiveSkew Whether trade increases skew in its direction
+ * @returns Price impact percentage (can be positive or negative)
+ */
+const calculateSkewPriceImpactP = (existingSkewToken, tradeSizeToken, skewDepth, tradePositiveSkew) => {
+    if (skewDepth === 0) {
+        return 0; // No impact if depth is 0
+    }
+    // Convert signed values based on trade direction
+    const tradeSkewMultiplier = tradePositiveSkew ? 1 : -1;
+    const signedExistingSkew = existingSkewToken;
+    const signedTradeSize = tradeSizeToken * tradeSkewMultiplier;
+    // (existingSkew + tradeSize/2) / skewDepth
+    const numerator = signedExistingSkew + signedTradeSize / 2;
+    const priceImpactP = numerator / skewDepth;
+    // Apply divider to match cumulative volume impact scale
+    return priceImpactP / PRICE_IMPACT_DIVIDER;
+};
+exports.calculateSkewPriceImpactP = calculateSkewPriceImpactP;
+/**
+ * @dev Main function to calculate skew price impact for a trade
+ * @param input Trade parameters
+ * @param context Skew price impact context with depths and OI data
+ * @returns Skew price impact result
+ */
+const getTradeSkewPriceImpact = (input, context) => {
+    // Get skew depth and pair OI from simplified context
+    const { skewDepth, pairOiToken: pairOi } = context;
+    // Calculate net skew
+    const netSkewToken = (0, exports.getNetSkewToken)(pairOi);
+    // Determine trade direction
+    const tradePositiveSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
+    // Calculate price impact
+    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 (totalPriceImpactP > 0) {
+        tradeDirection = "increase";
+    }
+    else if (totalPriceImpactP < 0) {
+        tradeDirection = "decrease";
+    }
+    else {
+        tradeDirection = "neutral";
+    }
+    return {
+        basePriceImpactP,
+        tradePriceImpactP,
+        totalPriceImpactP,
+        netSkewToken,
+        netSkewCollateral: 0,
+        tradeDirection,
+    };
+};
+exports.getTradeSkewPriceImpact = getTradeSkewPriceImpact;
+/**
+ * @dev Calculate position sizes for partial operations
+ * @param originalSizeCollateral Original position size in collateral
+ * @param deltaCollateral Position size delta in collateral
+ * @param originalSizeToken Original position size in tokens
+ * @returns Delta in tokens proportional to collateral delta
+ */
+const calculatePartialSizeToken = (originalSizeCollateral, deltaCollateral, originalSizeToken) => {
+    if (originalSizeCollateral === 0) {
+        return 0;
+    }
+    // For partial close/add, token delta is proportional to collateral delta
+    return (deltaCollateral * originalSizeToken) / originalSizeCollateral;
+};
+exports.calculatePartialSizeToken = calculatePartialSizeToken;
+// Export namespace for types
+exports.SkewPriceImpact = __importStar(require("./types"));
+__exportStar(require("./converter"), exports);
+__exportStar(require("./builder"), exports);
+__exportStar(require("./fetcher"), exports);

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

@@ -0,0 +1,44 @@
+/**
+ * @dev Skew price impact types for v10+ trades
+ */
+export type PairOiToken = {
+    oiLongToken: number;
+    oiShortToken: number;
+};
+export type PairOiCollateral = {
+    oiLongCollateral: number;
+    oiShortCollateral: number;
+};
+export type SkewPriceImpactInput = {
+    collateralIndex: number;
+    pairIndex: number;
+    long: boolean;
+    open: boolean;
+    positionSizeToken: number;
+};
+export type SkewPriceImpactResult = {
+    basePriceImpactP: number;
+    tradePriceImpactP: number;
+    totalPriceImpactP: number;
+    netSkewToken: number;
+    netSkewCollateral: number;
+    tradeDirection: "increase" | "decrease" | "neutral";
+};
+export type SkewPriceImpactContext = {
+    skewDepth: number;
+    pairOiToken: PairOiToken;
+};
+export type TradeSkewParams = {
+    collateralIndex: number;
+    pairIndex: number;
+    long: boolean;
+    open: boolean;
+    positionSizeCollateral: number;
+    currentPrice: number;
+    contractsVersion: number;
+    isCounterTrade?: boolean;
+};
+export type PositionSizeResult = {
+    positionSizeToken: number;
+    positionSizeCollateral: number;
+};

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @dev Skew price impact types for v10+ trades
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/trade/spread.d.ts

@@ -1,18 +1,5 @@
-import { LiquidationParams, OiWindows, OiWindowsSettings, PairDepth, PairFactor, UserPriceImpact } from "./types";
-import { ContractsVersion } from "../contracts/types";
-export type SpreadContext = {
-    isOpen?: boolean;
-    isPnlPositive?: boolean;
-    createdBlock?: number;
-    liquidationParams?: LiquidationParams | undefined;
-    currentBlock?: number | undefined;
-    contractsVersion?: ContractsVersion | undefined;
-    protectionCloseFactorWhitelist?: boolean;
-    userPriceImpact?: UserPriceImpact | undefined;
-} & Partial<PairFactor>;
-export declare const getProtectionCloseFactor: (spreadCtx: SpreadContext | undefined) => number;
-export declare const isProtectionCloseFactorActive: (spreadCtx: SpreadContext | undefined) => boolean | undefined;
-export declare const getCumulativeFactor: (spreadCtx: SpreadContext | undefined) => number;
-export declare const getLegacyFactor: (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, userPriceImpact?: UserPriceImpact | undefined) => number;
+/**
+ * @dev Pure spread calculations without price impact
+ * @dev For price impact calculations, see priceImpact module
+ */
+export { getSpreadWithPriceImpactP, getSpreadWithCumulVolPriceImpactP, getTradeCumulVolPriceImpactP, getCumulVolPriceImpact, getProtectionCloseFactor, isProtectionCloseFactorActive, getCumulativeFactor, getLegacyFactor, getFixedSpreadP, getSpreadP, CumulVolContext as SpreadContext, } from "./priceImpact/cumulVol";

package/lib/trade/spread.js

@@ -1,108 +1,19 @@
 "use strict";
+/**
+ * @dev Pure spread calculations without price impact
+ * @dev For price impact calculations, see priceImpact module
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSpreadP = exports.getSpreadWithPriceImpactP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = void 0;
-const oiWindows_1 = require("./oiWindows");
-const constants_1 = require("../constants");
-const types_1 = require("../contracts/types");
-const getProtectionCloseFactor = (spreadCtx) => {
-    var _a;
-    const protectionCloseFactor = spreadCtx === undefined ||
-        spreadCtx.contractsVersion === types_1.ContractsVersion.BEFORE_V9_2 ||
-        spreadCtx.isOpen === undefined ||
-        spreadCtx.isPnlPositive === undefined ||
-        spreadCtx.protectionCloseFactor === undefined ||
-        (0, exports.isProtectionCloseFactorActive)(spreadCtx) !== true
-        ? constants_1.DEFAULT_PROTECTION_CLOSE_FACTOR
-        : spreadCtx.protectionCloseFactor;
-    const protectionCloseFactorMultiplier = ((_a = spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.userPriceImpact) === null || _a === void 0 ? void 0 : _a.cumulVolPriceImpactMultiplier) !== undefined &&
-        spreadCtx.userPriceImpact.cumulVolPriceImpactMultiplier > 0
-        ? spreadCtx.userPriceImpact.cumulVolPriceImpactMultiplier
-        : 1;
-    return protectionCloseFactor * protectionCloseFactorMultiplier;
-};
-exports.getProtectionCloseFactor = getProtectionCloseFactor;
-const isProtectionCloseFactorActive = (spreadCtx) => {
-    if (spreadCtx === undefined ||
-        spreadCtx.currentBlock === undefined ||
-        spreadCtx.createdBlock === undefined ||
-        spreadCtx.protectionCloseFactorBlocks === undefined ||
-        spreadCtx.protectionCloseFactor === undefined) {
-        return undefined;
-    }
-    return (spreadCtx.isPnlPositive === true &&
-        spreadCtx.isOpen === false &&
-        spreadCtx.protectionCloseFactor > 0 &&
-        spreadCtx.currentBlock <=
-            spreadCtx.createdBlock + spreadCtx.protectionCloseFactorBlocks &&
-        spreadCtx.protectionCloseFactorWhitelist !== true);
-};
-exports.isProtectionCloseFactorActive = isProtectionCloseFactorActive;
-const getCumulativeFactor = (spreadCtx) => {
-    if (spreadCtx === undefined ||
-        spreadCtx.cumulativeFactor === undefined ||
-        spreadCtx.cumulativeFactor === 0) {
-        return constants_1.DEFAULT_CUMULATIVE_FACTOR;
-    }
-    return spreadCtx.cumulativeFactor;
-};
-exports.getCumulativeFactor = getCumulativeFactor;
-const getLegacyFactor = (spreadCtx) => {
-    return (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.contractsVersion) === types_1.ContractsVersion.BEFORE_V9_2 ? 1 : 2;
-};
-exports.getLegacyFactor = getLegacyFactor;
-const getSpreadWithPriceImpactP = (pairSpreadP, buy, collateral, leverage, pairDepth, oiWindowsSettings, oiWindows, spreadCtx) => {
-    if (pairSpreadP === undefined) {
-        return 0;
-    }
-    if (
-    // No spread or price impact when closing pre-v9.2 trades
-    ((spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) === false &&
-        (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.contractsVersion) === types_1.ContractsVersion.BEFORE_V9_2) ||
-        // No spread or price impact for opens when `pair.exemptOnOpen` is true
-        ((spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) === true && (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.exemptOnOpen) === true) ||
-        // No spread or price impact for closes after `protectionCloseFactor` has expired
-        // when `pair.exemptAfterProtectionCloseFactor` is true
-        ((spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.isOpen) === false &&
-            (spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.exemptAfterProtectionCloseFactor) === true &&
-            (0, exports.isProtectionCloseFactorActive)(spreadCtx) !== true)) {
-        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;
-    let activeOi = undefined;
-    if (oiWindowsSettings !== undefined) {
-        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);
-    }
-    if (!onePercentDepth || activeOi === undefined || collateral === undefined) {
-        return pairSpreadP / 2;
-    }
-    return ((0, exports.getSpreadP)(pairSpreadP, undefined, undefined, spreadCtx === null || spreadCtx === void 0 ? void 0 : spreadCtx.userPriceImpact) +
-        ((activeOi * (0, exports.getCumulativeFactor)(spreadCtx) + (collateral * leverage) / 2) /
-            onePercentDepth /
-            100 /
-            (0, exports.getLegacyFactor)(spreadCtx)) *
-            (0, exports.getProtectionCloseFactor)(spreadCtx));
-};
-exports.getSpreadWithPriceImpactP = getSpreadWithPriceImpactP;
-const getSpreadP = (pairSpreadP, isLiquidation, liquidationParams, userPriceImpact) => {
-    var _a;
-    const fixedSpreadP = (_a = userPriceImpact === null || userPriceImpact === void 0 ? void 0 : userPriceImpact.fixedSpreadP) !== null && _a !== void 0 ? _a : 0;
-    if (pairSpreadP === undefined || (pairSpreadP === 0 && fixedSpreadP === 0)) {
-        return 0;
-    }
-    const spreadP = pairSpreadP / 2 + fixedSpreadP;
-    return isLiquidation === true &&
-        liquidationParams !== undefined &&
-        liquidationParams.maxLiqSpreadP > 0 &&
-        spreadP > liquidationParams.maxLiqSpreadP
-        ? liquidationParams.maxLiqSpreadP
-        : spreadP;
-};
-exports.getSpreadP = getSpreadP;
+exports.getSpreadP = exports.getFixedSpreadP = exports.getLegacyFactor = exports.getCumulativeFactor = exports.isProtectionCloseFactorActive = exports.getProtectionCloseFactor = exports.getCumulVolPriceImpact = exports.getTradeCumulVolPriceImpactP = exports.getSpreadWithCumulVolPriceImpactP = exports.getSpreadWithPriceImpactP = void 0;
+// Re-export from priceImpact/cumulVol for backward compatibility
+var cumulVol_1 = require("./priceImpact/cumulVol");
+Object.defineProperty(exports, "getSpreadWithPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getSpreadWithPriceImpactP; } });
+Object.defineProperty(exports, "getSpreadWithCumulVolPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getSpreadWithCumulVolPriceImpactP; } });
+Object.defineProperty(exports, "getTradeCumulVolPriceImpactP", { enumerable: true, get: function () { return cumulVol_1.getTradeCumulVolPriceImpactP; } });
+Object.defineProperty(exports, "getCumulVolPriceImpact", { enumerable: true, get: function () { return cumulVol_1.getCumulVolPriceImpact; } });
+Object.defineProperty(exports, "getProtectionCloseFactor", { enumerable: true, get: function () { return cumulVol_1.getProtectionCloseFactor; } });
+Object.defineProperty(exports, "isProtectionCloseFactorActive", { enumerable: true, get: function () { return cumulVol_1.isProtectionCloseFactorActive; } });
+Object.defineProperty(exports, "getCumulativeFactor", { enumerable: true, get: function () { return cumulVol_1.getCumulativeFactor; } });
+Object.defineProperty(exports, "getLegacyFactor", { enumerable: true, get: function () { return cumulVol_1.getLegacyFactor; } });
+Object.defineProperty(exports, "getFixedSpreadP", { enumerable: true, get: function () { return cumulVol_1.getFixedSpreadP; } });
+Object.defineProperty(exports, "getSpreadP", { enumerable: true, get: function () { return cumulVol_1.getSpreadP; } });

package/lib/trade/types.d.ts

@@ -1,14 +1,37 @@
-import { ITradingStorage, IBorrowingFees, IPairsStorage } from "../contracts/types/generated/GNSMultiCollatDiamond";
+import { ITradingStorage, IBorrowingFees, IPairsStorage, IFundingFees } from "../contracts/types/generated/GNSMultiCollatDiamond";
 import { BorrowingFee } from "./fees/borrowing";
 import { FeeTier, TraderEnrollment, TraderInfo } from "./fees/tiers/types";
 export type PairIndexes = {
     [key: string]: PairIndex;
 };
+export type TradeFeesData = {
+    realizedTradingFeesCollateral: number;
+    realizedPnlCollateral: number;
+    manuallyRealizedNegativePnlCollateral: number;
+    alreadyTransferredNegativePnlCollateral: number;
+    virtualAvailableCollateralInDiamond: number;
+    initialAccFundingFeeP: number;
+    initialAccBorrowingFeeP: number;
+};
+export type UiRealizedPnlData = {
+    realizedTradingFeesCollateral: number;
+    realizedOldBorrowingFeesCollateral: number;
+    realizedNewBorrowingFeesCollateral: number;
+    realizedFundingFeesCollateral: number;
+    realizedPnlPartialCloseCollateral: number;
+    pnlWithdrawnCollateral: number;
+};
+export type CounterTradeSettings = {
+    maxLeverage: number;
+    feeRateMultiplier: number;
+};
 export type TradeContainer = {
     trade: Trade;
     tradeInfo: TradeInfo;
     liquidationParams: LiquidationParams;
     initialAccFees: TradeInitialAccFees;
+    tradeFeesData?: TradeFeesData;
+    uiRealizedPnlData?: UiRealizedPnlData;
     receivedAt?: number;
 };
 export type Trade = {
@@ -24,6 +47,8 @@ export type Trade = {
     openPrice: number;
     sl: number;
     tp: number;
+    isCounterTrade?: boolean;
+    positionSizeToken?: number;
 };
 export type TradeInfo = {
     createdBlock: number;
@@ -96,6 +121,86 @@ export type TradeHistoryRecord = {
     collateralDelta: number | null;
     leverageDelta: number | null;
     marketPrice: number | null;
+    meta: OpenTradeHistoryMetaData | CloseTradeHistoryMetaData | PartialCloseTradeHistoryMetaData | PartialOpenTradeHistoryMetaData | WithdrawPnLHistoryMetaData | LeverageUpdateHistoryMetaData;
+};
+export type HistoryPriceImpact = {
+    fixedSpreadP: number;
+    priceAfterImpact: number;
+    skewPriceImpactP: number;
+    positionSizeToken: number;
+    totalPriceImpactP: number;
+    cumulVolPriceImpactP: number;
+};
+export type OpenTradeHistoryMetaData = {
+    liqPrice: number;
+    amountSentToTrader: number;
+    percentProfit: number;
+    priceImpact: HistoryPriceImpact;
+    tradeFeesData: TradeFeesData;
+    uiRealizedPnlData: UiRealizedPnlData;
+};
+export type CloseTradeHistoryMetaData = OpenTradeHistoryMetaData;
+export type PartialOpenTradeHistoryMetaData = {
+    newLeverage: number;
+    newLiqPrice: number;
+    newOpenPrice: number;
+    existingLiqPrice: number;
+    newCollateralAmount: number;
+    newEffectiveLeverage: number;
+    existingPnlCollateral: number;
+    openingFeesCollateral: number;
+    isCounterTradeValidated: boolean;
+    newPositionSizeCollateral: number;
+    oldPosSizePlusPnlCollateral: number;
+    positionSizeCollateralDelta: number;
+    counterTradeCollateralToReturn: number;
+    existingPositionSizeCollateral: number;
+    exceedingPositionSizeCollateral: number;
+    priceImpact: HistoryPriceImpact;
+    tradeFeesData: TradeFeesData;
+    uiRealizedPnlData: UiRealizedPnlData;
+};
+export type PartialCloseTradeHistoryMetaData = {
+    newLeverage: number;
+    newLiqPrice: number;
+    existingLiqPrice: number;
+    isLeverageUpdate: boolean;
+    existingPnlPercent: number;
+    newCollateralAmount: number;
+    closingFeeCollateral: number;
+    collateralSentToTrader: number;
+    pnlToRealizeCollateral: number;
+    partialNetPnlCollateral: number;
+    partialRawPnlCollateral: number;
+    positionSizeCollateralDelta: number;
+    availableCollateralInDiamond: number;
+    existingPositionSizeCollateral: number;
+    totalAvailableCollateralInDiamond: number;
+    priceImpact: HistoryPriceImpact;
+    tradeFeesData: TradeFeesData;
+    uiRealizedPnlData: UiRealizedPnlData;
+};
+export type LeverageUpdateHistoryMetaData = {
+    availableCollateralInDiamond: number;
+    existingLiqPrice: number;
+    govFeeCollateral: number;
+    newCollateralAmount: number;
+    newEffectiveLeverage: number;
+    newLeverage: number;
+    newLiqPrice: number;
+    totalTradeAvailableCollateralInDiamond: number;
+    tradeFeesData: TradeFeesData;
+    uiRealizedPnlData: UiRealizedPnlData;
+};
+export type WithdrawPnLHistoryMetaData = {
+    pnlPercent: number;
+    currentPairPrice: number;
+    pnlInputCollateral: number;
+    pnlWithdrawnCollateral: number;
+    withdrawablePositivePnlCollateral: number;
+    priceImpact: HistoryPriceImpact;
+    tradeFeesData: TradeFeesData;
+    uiRealizedPnlData: UiRealizedPnlData;
 };
 export type MarketOrder = {
     trader: string;
@@ -143,6 +248,8 @@ export type TradeContainerRaw = {
     tradeInfo: ITradingStorage.TradeInfoStruct;
     liquidationParams: IPairsStorage.GroupLiquidationParamsStruct;
     initialAccFees: IBorrowingFees.BorrowingInitialAccFeesStruct;
+    tradeFeesData: IFundingFees.TradeFeesDataStruct;
+    uiRealizedPnlData?: IFundingFees.UiRealizedPnlDataStruct;
 };
 export type OiWindowsSettings = {
     startTs: number;
@@ -157,13 +264,6 @@ export type OiWindow = PairOi;
 export type OiWindows = {
     [key: string]: OiWindow;
 };
-export type CollateralConfig = {
-    collateral: string;
-    isActive: boolean;
-    precision: number;
-    precisionDelta: number;
-    decimals?: number;
-};
 export type FeeTiers = {
     tiers: FeeTier[];
     multipliers: number[];
@@ -619,8 +719,5 @@ export declare enum PairIndex {
     SBETUSD = 393,
     PLTRUSD = 394,
     BIDUUSD = 395,
-    ROKUUSD = 396,
-    LMTUSD = 397,
-    RIOTUSD = 398,
-    MARAUSD = 399
+    ROKUUSD = 396
 }

package/lib/trade/types.js

@@ -426,7 +426,4 @@ var PairIndex;
     PairIndex[PairIndex["PLTRUSD"] = 394] = "PLTRUSD";
     PairIndex[PairIndex["BIDUUSD"] = 395] = "BIDUUSD";
     PairIndex[PairIndex["ROKUUSD"] = 396] = "ROKUUSD";
-    PairIndex[PairIndex["LMTUSD"] = 397] = "LMTUSD";
-    PairIndex[PairIndex["RIOTUSD"] = 398] = "RIOTUSD";
-    PairIndex[PairIndex["MARAUSD"] = 399] = "MARAUSD";
 })(PairIndex = exports.PairIndex || (exports.PairIndex = {}));

package/lib/trade/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @dev Trade-specific utility functions
+ * @dev Common calculations and conversions used across trading modules
+ */
+/**
+ * @dev Converts position size from collateral to tokens
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param currentPrice Current pair price
+ * @returns Position size in tokens
+ */
+export declare const calculatePositionSizeToken: (positionSizeCollateral: number, currentPrice: number) => number;
+/**
+ * @dev Converts position size from tokens to collateral
+ * @param positionSizeToken Position size in tokens
+ * @param currentPrice Current pair price
+ * @returns Position size in collateral tokens
+ */
+export declare const calculatePositionSizeCollateral: (positionSizeToken: number, currentPrice: number) => number;

package/lib/trade/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @dev Trade-specific utility functions
+ * @dev Common calculations and conversions used across trading modules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePositionSizeCollateral = exports.calculatePositionSizeToken = void 0;
+/**
+ * @dev Converts position size from collateral to tokens
+ * @param positionSizeCollateral Position size in collateral tokens
+ * @param currentPrice Current pair price
+ * @returns Position size in tokens
+ */
+const calculatePositionSizeToken = (positionSizeCollateral, currentPrice) => {
+    if (currentPrice === 0) {
+        throw new Error("Current price cannot be zero");
+    }
+    return positionSizeCollateral / currentPrice;
+};
+exports.calculatePositionSizeToken = calculatePositionSizeToken;
+/**
+ * @dev Converts position size from tokens to collateral
+ * @param positionSizeToken Position size in tokens
+ * @param currentPrice Current pair price
+ * @returns Position size in collateral tokens
+ */
+const calculatePositionSizeCollateral = (positionSizeToken, currentPrice) => {
+    return positionSizeToken * currentPrice;
+};
+exports.calculatePositionSizeCollateral = calculatePositionSizeCollateral;

package/lib/vault/index.d.ts

@@ -4,5 +4,7 @@ type GetPendingAccBlockWeightedMarketCap = {
     accBlockWeightedMarketCapLastStored: number;
     marketCapPrecision?: number;
 };
-export declare const getPendingAccBlockWeightedMarketCap: (currentBlock: number, context: GetPendingAccBlockWeightedMarketCap) => number;
+export declare const getPendingAccBlockWeightedMarketCap: (input: {
+    currentBlock: number;
+}, context: GetPendingAccBlockWeightedMarketCap) => number;
 export {};

package/lib/vault/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPendingAccBlockWeightedMarketCap = void 0;
-const getPendingAccBlockWeightedMarketCap = (currentBlock, context) => {
+const getPendingAccBlockWeightedMarketCap = (input, context) => {
     const { marketCap, accBlockWeightedMarketCap, accBlockWeightedMarketCapLastStored, marketCapPrecision, } = context;
     return (accBlockWeightedMarketCap +
-        (currentBlock - accBlockWeightedMarketCapLastStored) /
+        (input.currentBlock - accBlockWeightedMarketCapLastStored) /
             Math.max(marketCap * (marketCapPrecision || 1e18), 1));
 };
 exports.getPendingAccBlockWeightedMarketCap = getPendingAccBlockWeightedMarketCap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.2.71-rc4",
+  "version": "1.0.0-rc1",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [
@@ -98,6 +98,7 @@
   },
   "dependencies": {
     "@ethersproject/providers": "^5.7.2",
+    "@gainsnetwork/contests": "^0.0.1",
     "ethcall": "^4.8.13",
     "ethers": "^5.7.2",
     "luxon": "^3.2.0"

package/lib/trade/liquidation.d.ts

@@ -1,12 +0,0 @@
-import { GetBorrowingFeeContext, BorrowingFee } from "./fees";
-import { Fee, LiquidationParams, Trade, UserPriceImpact } from "./types";
-import { ContractsVersion } from "../contracts/types";
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & {
-    liquidationParams: LiquidationParams | undefined;
-    pairSpreadP: number | undefined;
-    collateralPriceUsd: number | undefined;
-    contractsVersion: ContractsVersion | undefined;
-    userPriceImpact?: UserPriceImpact | 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;