@gainsnetwork/sdk 0.2.67-rc6 → 0.2.67-rc8

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

@@ -0,0 +1,179 @@
+"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.getTradeSkewPriceImpactWithChecks = exports.getTradeSkewPriceImpact = exports.calculateSkewPriceImpactP = exports.getTradeSkewDirection = exports.getNetSkewCollateral = exports.getNetSkewToken = void 0;
+const utils_1 = require("../../utils");
+// 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 tokens
+ * @param netSkewToken Net skew in tokens
+ * @param currentPrice Current pair price
+ * @returns Net skew in collateral tokens
+ */
+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 collateral tokens
+ * @param tradeIncreasesSkew Whether trade increases skew in its direction
+ * @returns Price impact percentage (can be positive or negative)
+ */
+const calculateSkewPriceImpactP = (existingSkewToken, tradeSizeToken, skewDepth, tradeIncreasesSkew) => {
+    if (skewDepth === 0) {
+        return 0; // No impact if depth is 0
+    }
+    // Convert signed values based on trade direction
+    const tradeSkewMultiplier = tradeIncreasesSkew ? 1 : -1;
+    const signedExistingSkew = existingSkewToken;
+    const signedTradeSize = tradeSizeToken * tradeSkewMultiplier;
+    // Formula: (existingSkew + tradeSize/2) / skewDepth
+    const numerator = signedExistingSkew + signedTradeSize / 2;
+    const priceImpactP = (numerator / skewDepth) * 100; // Convert to percentage
+    // 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 context Skew price impact context with depths and OI data
+ * @param input Trade parameters
+ * @returns Skew price impact result
+ */
+const getTradeSkewPriceImpact = (context, input) => {
+    var _a, _b;
+    // Get skew depth for the pair
+    const skewDepth = (_a = context.skewDepths[input.collateralIndex]) === null || _a === void 0 ? void 0 : _a[input.pairIndex];
+    if (skewDepth === undefined) {
+        throw new Error(`Missing skew depth for collateral ${input.collateralIndex} pair ${input.pairIndex}`);
+    }
+    // Get pair OI data
+    const pairOi = (_b = context.pairOiTokens[input.collateralIndex]) === null || _b === void 0 ? void 0 : _b[input.pairIndex];
+    if (!pairOi) {
+        throw new Error(`Missing pair OI data for collateral ${input.collateralIndex} pair ${input.pairIndex}`);
+    }
+    // Calculate net skew
+    const netSkewToken = (0, exports.getNetSkewToken)(pairOi);
+    // Determine trade direction impact
+    const tradeIncreasesSkew = (0, exports.getTradeSkewDirection)(input.long, input.open);
+    // Calculate price impact
+    const priceImpactP = (0, exports.calculateSkewPriceImpactP)(netSkewToken, input.positionSizeToken, skewDepth, tradeIncreasesSkew);
+    // Determine trade direction relative to skew
+    let tradeDirection;
+    if (priceImpactP > 0) {
+        tradeDirection = "increase";
+    }
+    else if (priceImpactP < 0) {
+        tradeDirection = "decrease";
+    }
+    else {
+        tradeDirection = "neutral";
+    }
+    return {
+        priceImpactP,
+        netSkewToken,
+        netSkewCollateral: 0,
+        tradeDirection,
+    };
+};
+exports.getTradeSkewPriceImpact = getTradeSkewPriceImpact;
+/**
+ * @dev Calculate skew price impact for a trade with all parameters
+ * @param params Trade parameters including price and version checks
+ * @param context Skew price impact context
+ * @returns Price impact percentage or 0 if not applicable
+ */
+const getTradeSkewPriceImpactWithChecks = (params, context) => {
+    // v10+ trades only
+    if (params.contractsVersion < 10) {
+        return 0;
+    }
+    // Counter trades don't pay skew impact
+    if (params.isCounterTrade) {
+        return 0;
+    }
+    // Calculate position size in tokens
+    const positionSizeToken = (0, utils_1.calculatePositionSizeToken)(params.positionSizeCollateral, params.currentPrice);
+    // Get skew price impact
+    const result = (0, exports.getTradeSkewPriceImpact)(context, {
+        collateralIndex: params.collateralIndex,
+        pairIndex: params.pairIndex,
+        long: params.long,
+        open: params.open,
+        positionSizeToken,
+    });
+    return result.priceImpactP;
+};
+exports.getTradeSkewPriceImpactWithChecks = getTradeSkewPriceImpactWithChecks;
+/**
+ * @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("./fetcher"), exports);

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

@@ -0,0 +1,55 @@
+/**
+ * @dev Skew price impact types for v10+ trades
+ */
+export type PairOiToken = {
+    oiLongToken: number;
+    oiShortToken: number;
+};
+export type PairOiCollateral = {
+    oiLongCollateral: number;
+    oiShortCollateral: number;
+};
+export type SkewDepth = {
+    collateralIndex: number;
+    pairIndex: number;
+    depth: number;
+};
+export type SkewPriceImpactInput = {
+    collateralIndex: number;
+    pairIndex: number;
+    long: boolean;
+    open: boolean;
+    positionSizeToken: number;
+};
+export type SkewPriceImpactResult = {
+    priceImpactP: number;
+    netSkewToken: number;
+    netSkewCollateral: number;
+    tradeDirection: "increase" | "decrease" | "neutral";
+};
+export type SkewPriceImpactContext = {
+    skewDepths: {
+        [collateralIndex: number]: {
+            [pairIndex: number]: number;
+        };
+    };
+    pairOiTokens: {
+        [collateralIndex: number]: {
+            [pairIndex: number]: 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/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/package.json

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