@gainsnetwork/sdk 0.0.0-v10.rc15 → 0.0.0-v10.rc17

package/lib/backend/tradingVariables/converter.js

@@ -187,7 +187,7 @@ const convertTrade = (trade, collaterals) => {
         tp: parseFloat(trade.tp) / 1e10,
         isCounterTrade: trade.isCounterTrade,
         positionSizeToken: trade.positionSizeToken
-            ? parseFloat(trade.positionSizeToken) / Math.pow(10, decimals)
+            ? parseFloat(trade.positionSizeToken) / 1e18
             : undefined,
     };
 };

package/lib/constants.d.ts

@@ -386,6 +386,16 @@ export declare const pairs: {
     "BVIV/USD": string;
     "EVIV/USD": string;
     "CRCL/USD": string;
+    "RESOLV/USD": string;
+    "SQD/USD": string;
+    "TAIKO/USD": string;
+    "HOME/USD": string;
+    "B/USD": string;
+    "HUMA/USD": string;
+    "SBET/USD": string;
+    "PLTR/USD": string;
+    "BIDU/USD": string;
+    "ROKU/USD": string;
 };
 export declare const syntheticPairs: Set<string>;
 export declare const parentToSyntheticPairMap: Map<string, string>;

package/lib/constants.js

@@ -394,6 +394,16 @@ exports.pairs = {
     "BVIV/USD": CRYPTO,
     "EVIV/USD": CRYPTO,
     "CRCL/USD": STOCKS,
+    "RESOLV/USD": CRYPTO,
+    "SQD/USD": CRYPTO,
+    "TAIKO/USD": CRYPTO,
+    "HOME/USD": CRYPTO,
+    "B/USD": CRYPTO,
+    "HUMA/USD": CRYPTO,
+    "SBET/USD": STOCKS,
+    "PLTR/USD": STOCKS,
+    "BIDU/USD": STOCKS,
+    "ROKU/USD": STOCKS,
 };
 exports.syntheticPairs = new Set([
     "BTCDEGEN/USD",
@@ -442,11 +452,12 @@ exports.stockSplits = {
 };
 exports.delistedPairIxs = new Set([
     4, 6, 15, 24, 25, 27, 28, 30, 31, 36, 48, 51, 52, 53, 54, 56, 59, 60, 61, 63,
-    66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 95, 96, 97, 98,
-    99, 101, 106, 111, 113, 114, 116, 118, 120, 122, 123, 125, 127, 130, 147, 152,
+    66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 95, 96, 97, 98, 99,
+    101, 106, 111, 113, 114, 116, 118, 120, 122, 123, 125, 127, 130, 147, 152,
     160, 163, 170, 179, 182, 183, 187, 188, 189, 190, 208, 209, 225, 229, 230,
     231, 238, 239, 241, 250, 253, 254, 258, 270, 275, 276, 278, 279, 282, 285,
     290, 294, 296, 305, 330, 349, 352, 353, 354, 355, 357, 365, 366, 384, 385,
+    393, 394, 395, 396,
 ]);
 exports.delistedGroupsIxs = new Set([]);
 exports.DEFAULT_PROTECTION_CLOSE_FACTOR = 1;

package/lib/contracts/addresses.json

@@ -22,6 +22,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "42161": {
@@ -47,6 +51,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x4ca1638754Be8060E544Aca4A4F43702Be30E0D1",
             "gToken": "0x4BeeF1113F968326905224D2Ca272f3032A9a9F4"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "421614": {
@@ -72,6 +80,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x68F8D4ec2EF23a15e61e1642E730b6f69fB9A5De",
             "gToken": "0x5ed4bEA869300DB39bE2a92a8B42e53453742a43"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     },
     "8453": {
@@ -97,6 +109,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0xA22F7b92d81Dd74bE5ca5758DF3FccF0A4CB19cc",
+            "gToken": "0xB7Cb7cB7C3cD96e251c9bF8800B9631134BbAdc6"
         }
     },
     "33139": {
@@ -122,6 +138,10 @@
         "GNS": {
             "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
             "gToken": "0x0000000000000000000000000000000000000000"
+        },
+        "BTCUSD": {
+            "gTokenOpenPnlFeed": "0x0000000000000000000000000000000000000000",
+            "gToken": "0x0000000000000000000000000000000000000000"
         }
     }
 }

package/lib/contracts/index.js

@@ -63,6 +63,7 @@ exports.COLLATERAL_TO_CHAIN_COLLATERAL_INDEX = {
     },
     [types_1.ChainId.BASE]: {
         [types_1.CollateralTypes.USDC]: 1,
+        [types_1.CollateralTypes.BTCUSD]: 2,
     },
     [types_1.ChainId.APECHAIN]: {
         [types_1.CollateralTypes.APE]: 1,
@@ -75,7 +76,8 @@ exports.COLLATERAL_TO_COLLATERAL_INDEX = {
     [types_1.CollateralTypes.USDC]: 3,
     [types_1.CollateralTypes.ARB]: 0,
     [types_1.CollateralTypes.APE]: 0,
-    [types_1.CollateralTypes.GNS]: 0, // not in use
+    [types_1.CollateralTypes.GNS]: 0,
+    [types_1.CollateralTypes.BTCUSD]: 0,
 };
 __exportStar(require("./utils"), exports);
 __exportStar(require("./addresses"), exports);

package/lib/contracts/types/index.d.ts

@@ -16,7 +16,8 @@ export declare enum CollateralTypes {
     ARB = "ARB",
     USDC = "USDC",
     APE = "APE",
-    GNS = "GNS"
+    GNS = "GNS",
+    BTCUSD = "BTCUSD"
 }
 export declare enum ContractsVersion {
     BEFORE_V9_2 = 0,

package/lib/contracts/types/index.js

@@ -9,6 +9,7 @@ var CollateralTypes;
     CollateralTypes["USDC"] = "USDC";
     CollateralTypes["APE"] = "APE";
     CollateralTypes["GNS"] = "GNS";
+    CollateralTypes["BTCUSD"] = "BTCUSD";
 })(CollateralTypes = exports.CollateralTypes || (exports.CollateralTypes = {}));
 var ContractsVersion;
 (function (ContractsVersion) {

package/lib/contracts/utils/pairs.js

@@ -492,4 +492,14 @@ const PAIR_INDEX_TO_DESCRIPTION = {
     [types_1.PairIndex.BVIVUSD]: "Bitcoin Volmex Implied Volatility 30 Day Index to US Dollar",
     [types_1.PairIndex.EVIVUSD]: "Ethereum Volmex Implied Volatility 30 Day Index to US Dollar",
     [types_1.PairIndex.CRCLUSD]: "Circle Internet Group to US Dollar",
+    [types_1.PairIndex.RESOLVUSD]: "Resolv to US Dollar",
+    [types_1.PairIndex.SQDUSD]: "Subsquid to US Dollar",
+    [types_1.PairIndex.TAIKOUSD]: "Taiko to US Dollar",
+    [types_1.PairIndex.HOMEUSD]: "Defi App to US Dollar",
+    [types_1.PairIndex.BUSD]: "BUILDon to US Dollar",
+    [types_1.PairIndex.HUMAUSD]: "Huma Finance to US Dollar",
+    [types_1.PairIndex.SBETUSD]: "Sharplink Gaming Inc to US Dollar",
+    [types_1.PairIndex.PLTRUSD]: "Palantir Technologies to US Dollar",
+    [types_1.PairIndex.BIDUUSD]: "Baidu to US Dollar",
+    [types_1.PairIndex.ROKUUSD]: "Roku to US Dollar",
 };

package/lib/trade/effectiveLeverage/builder.d.ts

@@ -0,0 +1,23 @@
+import { GlobalTradingVariablesType } from "../../backend/tradingVariables/types";
+import { TradeInfo } from "..";
+import { TradeEffectiveLeverageContext } from "./types";
+/**
+ * @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
+ */
+export declare const buildTradeEffectiveLeverageContext: (globalTradingVariables: GlobalTradingVariablesType, collateralIndex: number, pairIndex: number, tradeInfo: TradeInfo, additionalParams: {
+    currentBlock: number;
+    contractsVersion?: number;
+    isPnlPositive?: boolean;
+    userPriceImpact?: {
+        cumulVolPriceImpactMultiplier: number;
+        fixedSpreadP: number;
+    };
+    protectionCloseFactorWhitelist?: boolean;
+}) => TradeEffectiveLeverageContext | undefined;

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/effectiveLeverage/getTradeNewEffectiveLeverage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @dev Trade effective leverage calculations
+ * @dev Mirrors contract's TradingCommonUtils.getTradeNewEffectiveLeverage
+ */
+import { TradeEffectiveLeverageInput, TradeEffectiveLeverageContext, TradeEffectiveLeverageResult } from "./types";
+export type { TradeEffectiveLeverageInput, TradeEffectiveLeverageContext, TradeEffectiveLeverageResult, };
+export { buildTradeEffectiveLeverageContext } from "./builder";
+/**
+ * @dev Calculates the effective leverage of a trade accounting for unrealized PnL
+ * @dev Effective leverage increases when PnL is negative and decreases when positive
+ * @dev Mirrors contract's getTradeNewEffectiveLeverage function
+ * @param input Trade parameters including new position values
+ * @param context Combined context for calculations
+ * @returns Effective leverage and related values
+ */
+export declare const getTradeNewEffectiveLeverage: (input: TradeEffectiveLeverageInput, context: TradeEffectiveLeverageContext) => TradeEffectiveLeverageResult;
+/**
+ * @dev Simplified version for existing positions (no opening fees)
+ * @param input Trade parameters
+ * @param context Combined context
+ * @returns Effective leverage and related values
+ */
+export declare const getTradeEffectiveLeverage: (input: Omit<TradeEffectiveLeverageInput, "openingFeesCollateral">, context: TradeEffectiveLeverageContext) => TradeEffectiveLeverageResult;

package/lib/trade/effectiveLeverage/getTradeNewEffectiveLeverage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeEffectiveLeverage = exports.getTradeNewEffectiveLeverage = exports.buildTradeEffectiveLeverageContext = void 0;
+const __1 = require("..");
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildTradeEffectiveLeverageContext", { enumerable: true, get: function () { return builder_1.buildTradeEffectiveLeverageContext; } });
+/**
+ * @dev Calculates the effective leverage of a trade accounting for unrealized PnL
+ * @dev Effective leverage increases when PnL is negative and decreases when positive
+ * @dev Mirrors contract's getTradeNewEffectiveLeverage function
+ * @param input Trade parameters including new position values
+ * @param context Combined context for calculations
+ * @returns Effective leverage and related values
+ */
+const getTradeNewEffectiveLeverage = (input, context) => {
+    const { trade, newOpenPrice, newCollateralAmount, newLeverage, currentPairPrice, openingFeesCollateral, } = input;
+    const { closingPriceImpactContext } = context;
+    // Calculate new position size
+    const newPositionSize = newCollateralAmount * newLeverage;
+    // Calculate price impact for closing at current price
+    const closingPriceImpact = (0, __1.getTradeClosingPriceImpact)({
+        trade: Object.assign(Object.assign({}, trade), { openPrice: newOpenPrice, collateralAmount: newCollateralAmount, leverage: newLeverage }),
+        oraclePrice: currentPairPrice,
+        positionSizeCollateral: newPositionSize,
+        currentPairPrice: currentPairPrice,
+        useCumulativeVolPriceImpact: true,
+        collateralIndex: trade.collateralIndex,
+        pairIndex: trade.pairIndex,
+        pairSpreadP: context.baseSpreadP,
+        contractsVersion: closingPriceImpactContext.tradeInfo.contractsVersion,
+    }, closingPriceImpactContext);
+    // Calculate unrealized PnL
+    // For longs: (exitPrice - entryPrice) * positionSizeToken
+    // For shorts: (entryPrice - exitPrice) * positionSizeToken
+    const priceDiff = trade.long
+        ? closingPriceImpact.priceAfterImpact - newOpenPrice
+        : newOpenPrice - closingPriceImpact.priceAfterImpact;
+    const unrealizedPnl = priceDiff * closingPriceImpact.positionSizeToken;
+    // Calculate effective collateral (collateral + PnL - fees)
+    // Note: fees are subtracted because they reduce the effective collateral
+    const effectiveCollateral = newCollateralAmount + unrealizedPnl - openingFeesCollateral;
+    // Calculate effective leverage
+    // If effective collateral is <= 0, leverage is effectively infinite
+    const effectiveLeverage = effectiveCollateral > 0
+        ? newPositionSize / effectiveCollateral
+        : Number.MAX_SAFE_INTEGER;
+    return {
+        effectiveLeverage,
+        unrealizedPnl,
+        effectiveCollateral,
+        positionSize: newPositionSize,
+    };
+};
+exports.getTradeNewEffectiveLeverage = getTradeNewEffectiveLeverage;
+/**
+ * @dev Simplified version for existing positions (no opening fees)
+ * @param input Trade parameters
+ * @param context Combined context
+ * @returns Effective leverage and related values
+ */
+const getTradeEffectiveLeverage = (input, context) => {
+    return (0, exports.getTradeNewEffectiveLeverage)(Object.assign(Object.assign({}, input), { openingFeesCollateral: 0 }), context);
+};
+exports.getTradeEffectiveLeverage = getTradeEffectiveLeverage;

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

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./builder";
+export { getTradeNewEffectiveLeverage, getTradeEffectiveLeverage, } from "./getTradeNewEffectiveLeverage";

package/lib/trade/effectiveLeverage/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __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.getTradeEffectiveLeverage = exports.getTradeNewEffectiveLeverage = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./builder"), exports);
+var getTradeNewEffectiveLeverage_1 = require("./getTradeNewEffectiveLeverage");
+Object.defineProperty(exports, "getTradeNewEffectiveLeverage", { enumerable: true, get: function () { return getTradeNewEffectiveLeverage_1.getTradeNewEffectiveLeverage; } });
+Object.defineProperty(exports, "getTradeEffectiveLeverage", { enumerable: true, get: function () { return getTradeNewEffectiveLeverage_1.getTradeEffectiveLeverage; } });

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

@@ -0,0 +1,33 @@
+/**
+ * @dev Types for trade effective leverage calculations
+ */
+import { Trade, TradeClosingPriceImpactContext } from "..";
+/**
+ * @dev Input parameters for effective leverage calculation
+ * @dev Mirrors contract's parameters for getTradeNewEffectiveLeverage
+ */
+export type TradeEffectiveLeverageInput = {
+    trade: Trade;
+    newOpenPrice: number;
+    newCollateralAmount: number;
+    newLeverage: number;
+    currentPairPrice: number;
+    openingFeesCollateral: number;
+};
+/**
+ * @dev Context for effective leverage calculation
+ * Includes closing price impact context for PnL calculations
+ */
+export type TradeEffectiveLeverageContext = {
+    closingPriceImpactContext: TradeClosingPriceImpactContext;
+    baseSpreadP: number;
+};
+/**
+ * @dev Result of effective leverage calculation
+ */
+export type TradeEffectiveLeverageResult = {
+    effectiveLeverage: number;
+    unrealizedPnl: number;
+    effectiveCollateral: number;
+    positionSize: number;
+};

package/lib/trade/effectiveLeverage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -19,7 +19,6 @@ export type GetBorrowingFeeContext = {
  */
 export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex | undefined, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;
 /**
- * @deprecated Use withinMaxGroupOiDynamic from @gains-network/sdk/markets/oi instead
  * @dev This function uses static OI which doesn't reflect current market values
  * @dev The v10 contracts use dynamic OI (beforeV10 + afterV10Token * currentPrice)
  */

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

@@ -78,7 +78,6 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
 };
 exports.getBorrowingFee = getBorrowingFee;
 /**
- * @deprecated Use withinMaxGroupOiDynamic from @gains-network/sdk/markets/oi instead
  * @dev This function uses static OI which doesn't reflect current market values
  * @dev The v10 contracts use dynamic OI (beforeV10 + afterV10Token * currentPrice)
  */

package/lib/trade/index.d.ts

@@ -6,3 +6,4 @@ export * from "./types";
 export * from "./oiWindows";
 export * from "./priceImpact";
 export * from "./utils";
+export * from "./effectiveLeverage";

package/lib/trade/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./oiWindows"), exports);
 __exportStar(require("./priceImpact"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./effectiveLeverage"), exports);

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

@@ -53,6 +53,11 @@ const getTradeClosingPriceImpact = (input, context) => {
     const positionSizeToken = input.trade.positionSizeToken
         ? calculateClosingPositionSizeToken(input.positionSizeCollateral, input.trade.positionSizeToken, input.trade.collateralAmount, input.trade.leverage)
         : 0;
+    console.log("positionSizeToken", positionSizeToken);
+    console.log("input.positionSizeCollateral", input.positionSizeCollateral);
+    console.log("input.trade.positionSizeToken", input.trade.positionSizeToken);
+    console.log("input.trade.collateralAmount", input.trade.collateralAmount);
+    console.log("input.trade.leverage", input.trade.leverage);
     // Calculate fixed spread (reversed for closing)
     const fixedSpreadP = (0, cumulVol_1.getFixedSpreadP)(input.pairSpreadP, input.trade.long, false // closing
     );
@@ -74,7 +79,6 @@ const getTradeClosingPriceImpact = (input, context) => {
         );
         // Determine actual PnL from the calculated percentage
         const isPnlPositive = pnlPercent > 0;
-        console.log("isPnlPositive", isPnlPositive);
         // Second pass: Recalculate with actual PnL if positive
         if (isPnlPositive) {
             cumulVolPriceImpactP = (0, cumulVol_1.getTradeCumulVolPriceImpactP)(input.trade.user, input.pairIndex, input.trade.long, positionSizeUsd, true, // Positive PnL

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

@@ -43,13 +43,6 @@ const isProtectionCloseFactorActive = (context) => {
         context.protectionCloseFactor === undefined) {
         return undefined;
     }
-    console.log("context.isPnlPositive", context.isPnlPositive);
-    console.log("context.isOpen", context.isOpen);
-    console.log("context.protectionCloseFactor", context.protectionCloseFactor);
-    console.log("context.currentBlock", context.currentBlock);
-    console.log("context.createdBlock", context.createdBlock);
-    console.log("context.protectionCloseFactorBlocks", context.protectionCloseFactorBlocks);
-    console.log("context.protectionCloseFactorWhitelist", context.protectionCloseFactorWhitelist);
     return (context.isPnlPositive === true &&
         context.isOpen === false &&
         context.protectionCloseFactor > 0 &&
@@ -135,12 +128,6 @@ const getTradeCumulVolPriceImpactP = (trader, pairIndex, long, tradeOpenInterest
         onePercentDepth /
         (0, exports.getLegacyFactor)(updatedContext)) *
         (0, exports.getProtectionCloseFactor)(updatedContext);
-    console.log("signedActiveOi", signedActiveOi);
-    console.log("getCumulativeFactor", (0, exports.getCumulativeFactor)(updatedContext));
-    console.log("signedTradeOi", signedTradeOi);
-    console.log("onePercentDepth", onePercentDepth);
-    console.log("getLegacyFactor", (0, exports.getLegacyFactor)(updatedContext));
-    console.log("getProtectionCloseFactor", (0, exports.getProtectionCloseFactor)(updatedContext));
     return finalPriceImpactP;
 };
 exports.getTradeCumulVolPriceImpactP = getTradeCumulVolPriceImpactP;

package/lib/trade/types.d.ts

@@ -629,5 +629,15 @@ export declare enum PairIndex {
     LPTUSD = 383,
     BVIVUSD = 384,
     EVIVUSD = 385,
-    CRCLUSD = 386
+    CRCLUSD = 386,
+    RESOLVUSD = 387,
+    SQDUSD = 388,
+    TAIKOUSD = 389,
+    HOMEUSD = 390,
+    BUSD = 391,
+    HUMAUSD = 392,
+    SBETUSD = 393,
+    PLTRUSD = 394,
+    BIDUUSD = 395,
+    ROKUUSD = 396
 }

package/lib/trade/types.js

@@ -416,4 +416,14 @@ var PairIndex;
     PairIndex[PairIndex["BVIVUSD"] = 384] = "BVIVUSD";
     PairIndex[PairIndex["EVIVUSD"] = 385] = "EVIVUSD";
     PairIndex[PairIndex["CRCLUSD"] = 386] = "CRCLUSD";
+    PairIndex[PairIndex["RESOLVUSD"] = 387] = "RESOLVUSD";
+    PairIndex[PairIndex["SQDUSD"] = 388] = "SQDUSD";
+    PairIndex[PairIndex["TAIKOUSD"] = 389] = "TAIKOUSD";
+    PairIndex[PairIndex["HOMEUSD"] = 390] = "HOMEUSD";
+    PairIndex[PairIndex["BUSD"] = 391] = "BUSD";
+    PairIndex[PairIndex["HUMAUSD"] = 392] = "HUMAUSD";
+    PairIndex[PairIndex["SBETUSD"] = 393] = "SBETUSD";
+    PairIndex[PairIndex["PLTRUSD"] = 394] = "PLTRUSD";
+    PairIndex[PairIndex["BIDUUSD"] = 395] = "BIDUUSD";
+    PairIndex[PairIndex["ROKUUSD"] = 396] = "ROKUUSD";
 })(PairIndex = exports.PairIndex || (exports.PairIndex = {}));

package/package.json

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