@reyaxyz/api-sdk 0.26.0 → 0.28.0

package/src/clients/helpers/exposure.calculator.ts

@@ -1,799 +0,0 @@
-import BigNumber from 'bignumber.js';
-import _ from 'lodash';
-import {
-  AccountAssetBalance,
-  CollateralInfo,
-  ExchangeInfo,
-  ExposureCommandState,
-  MarginInfo,
-  MarketConfiguration,
-  MarketIdToOraclePriceMap,
-  MarketStorage,
-  PositionInfo,
-  PositionInfoMarketConfiguration,
-  RiskMatrix,
-  RiskMultipliersConfiguration,
-} from './trade.simulation.types';
-import { amountNormalizer } from './number';
-
-export class ExposureCommand {
-  rootCollateralPoolId: number;
-  oraclePricePerMarket: MarketIdToOraclePriceMap;
-  accountBalancePerAsset: AccountAssetBalance[];
-  groupedByCollateral: Record<string, AccountAssetBalance>;
-  riskMultipliers: RiskMultipliersConfiguration;
-  riskMatrices: RiskMatrix[];
-  exchangeInfoPerAsset: ExchangeInfo[];
-  positionInfoMarketConfiguration: PositionInfoMarketConfiguration[];
-  uniqueTokenAddresses: string[];
-  uniqueQuoteCollaterals: string[];
-  tokenMarginInfoPerAsset: MarginInfo[];
-  realizedPnLSum: BigNumber;
-  unrealizedPnLSum: BigNumber;
-  constructor(
-    rootCollateralPoolId: number,
-    oraclePricePerMarket: MarketIdToOraclePriceMap,
-    accountBalancePerAsset: AccountAssetBalance[],
-    groupedByCollateral: Record<string, AccountAssetBalance>,
-    riskMultipliers: RiskMultipliersConfiguration,
-    riskMatrices: RiskMatrix[],
-    exchangeInfoPerAsset: ExchangeInfo[],
-    positionInfoMarketConfiguration: PositionInfoMarketConfiguration[],
-    uniqueTokenAddresses: string[],
-    uniqueQuoteCollaterals: string[],
-    tokenMarginInfoPerAsset: MarginInfo[],
-    realizedPnLSum: BigNumber,
-    unrealizedPnLSum: BigNumber,
-  ) {
-    this.rootCollateralPoolId = rootCollateralPoolId;
-    this.oraclePricePerMarket = oraclePricePerMarket;
-    this.accountBalancePerAsset = accountBalancePerAsset;
-    this.groupedByCollateral = groupedByCollateral;
-    this.riskMultipliers = riskMultipliers;
-    this.riskMatrices = riskMatrices;
-    this.exchangeInfoPerAsset = exchangeInfoPerAsset;
-    this.positionInfoMarketConfiguration = positionInfoMarketConfiguration;
-    this.uniqueTokenAddresses = uniqueTokenAddresses;
-    this.uniqueQuoteCollaterals = uniqueQuoteCollaterals;
-    this.tokenMarginInfoPerAsset = tokenMarginInfoPerAsset;
-    this.realizedPnLSum = realizedPnLSum;
-    this.unrealizedPnLSum = unrealizedPnLSum;
-  }
-
-  getState(): ExposureCommandState {
-    return {
-      rootCollateralPoolId: this.rootCollateralPoolId,
-      oraclePricePerMarket: this.oraclePricePerMarket,
-      accountBalancePerAsset: this.accountBalancePerAsset,
-      groupedByCollateral: this.groupedByCollateral,
-      riskMultipliers: this.riskMultipliers,
-      riskMatrices: this.riskMatrices,
-      exchangeInfoPerAsset: this.exchangeInfoPerAsset,
-      positionInfoMarketConfiguration: this.positionInfoMarketConfiguration,
-      uniqueTokenAddresses: this.uniqueTokenAddresses,
-      uniqueQuoteCollaterals: this.uniqueQuoteCollaterals,
-      tokenMarginInfoPerAsset: this.tokenMarginInfoPerAsset,
-      realizedPnLSum: this.realizedPnLSum,
-      unrealizedPnLSum: this.unrealizedPnLSum,
-    };
-  }
-
-  get getUsdNodeMarginInfo() {
-    return ExposureCommand.getUsdNodeMarginInfo(
-      this.rootCollateralPoolId,
-      this.uniqueTokenAddresses,
-      this.exchangeInfoPerAsset,
-      this.tokenMarginInfoPerAsset,
-    );
-  }
-
-  get balancePerAsset() {
-    return this.tokenMarginInfoPerAsset;
-  }
-  get exchangePricePerAsset() {
-    return this.exchangeInfoPerAsset;
-  }
-
-  getUsdNodeMarginInfoPostTrade(
-    positionAmount: number,
-    collateralAddress: string,
-    marketConfiguration: MarketConfiguration,
-  ) {
-    // perform deep copy of the object
-    const positionInfoMarketConfiguration: PositionInfoMarketConfiguration[] =
-      _.cloneDeep(this.positionInfoMarketConfiguration);
-
-    // Check if the market_id already exists in the array
-    const existingConfigIndex = positionInfoMarketConfiguration.findIndex(
-      (config) =>
-        config.market_id ===
-        BigNumber(String(marketConfiguration.market_id)).toNumber(),
-    );
-
-    if (existingConfigIndex !== -1) {
-      // If it exists, update the amount
-      positionInfoMarketConfiguration[existingConfigIndex].base = BigNumber(
-        positionInfoMarketConfiguration[existingConfigIndex].base,
-      ).plus(positionAmount);
-    } else {
-      // If it doesn't exist, add a new element
-      positionInfoMarketConfiguration.push({
-        base: BigNumber(positionAmount),
-        realized_pnl: BigNumber(0),
-        last_price: BigNumber(0),
-        last_timestamp: BigNumber(0),
-        funding_value: BigNumber(0),
-        base_multiplier: BigNumber(0),
-        adl_unwind_price: BigNumber(0),
-        market_id: BigNumber(String(marketConfiguration.market_id)).toNumber(),
-        market_configuration: marketConfiguration,
-      });
-    }
-
-    const uniqueQuoteCollaterals = new Set(this.uniqueQuoteCollaterals);
-    uniqueQuoteCollaterals.add(collateralAddress);
-
-    const tokenMarginInfoPerAsset =
-      ExposureCommand.calculateTokenMarginInfoPerAsset(
-        this.groupedByCollateral,
-        this.rootCollateralPoolId,
-        this.riskMatrices,
-        this.riskMultipliers,
-        uniqueQuoteCollaterals,
-        this.realizedPnLSum,
-        this.unrealizedPnLSum,
-        positionInfoMarketConfiguration,
-        this.oraclePricePerMarket,
-      );
-
-    const uniqueTokenAddresses = [...this.uniqueTokenAddresses];
-    if (!this.uniqueTokenAddresses.includes(collateralAddress)) {
-      uniqueTokenAddresses.push(collateralAddress);
-    }
-
-    return ExposureCommand.getUsdNodeMarginInfo(
-      this.rootCollateralPoolId,
-      uniqueTokenAddresses,
-      this.exchangeInfoPerAsset,
-      tokenMarginInfoPerAsset,
-    );
-  }
-
-  static calculateTokenMarginInfoPerAsset(
-    groupedByCollateral: Record<string, AccountAssetBalance>,
-    rootCollateralPoolId: number,
-    riskMatrices: RiskMatrix[],
-    riskMultipliers: RiskMultipliersConfiguration,
-    uniqueQuoteCollaterals: Set<string>,
-    realizedPnLSum: BigNumber,
-    unrealizedPnLSum: BigNumber,
-    positionInfoMarketConfiguration: PositionInfoMarketConfiguration[],
-    oraclePricePerMarket: MarketIdToOraclePriceMap,
-  ): MarginInfo[] {
-    const tokenMarginInfoPerAsset: MarginInfo[] = [];
-
-    const uniqueQuoteTokens: string[] = Array.from(uniqueQuoteCollaterals);
-
-    const tokenUnion = new Set([
-      ...Object.keys(groupedByCollateral),
-      ...uniqueQuoteTokens,
-    ]); // get unique union of those arrays
-    const uniqueTokenAddresses: string[] = Array.from(tokenUnion);
-
-    for (const token of uniqueTokenAddresses) {
-      tokenMarginInfoPerAsset.push(
-        ExposureCommand.getTokenMarginInfo(
-          rootCollateralPoolId,
-          riskMatrices,
-          riskMultipliers,
-          ExposureCommand.getCollateralInfo(
-            token,
-            uniqueQuoteCollaterals.has(token) ? realizedPnLSum : BigNumber(0),
-            uniqueQuoteCollaterals.has(token) ? unrealizedPnLSum : BigNumber(0),
-            groupedByCollateral[token]?.amount || 0,
-          ),
-          token,
-          positionInfoMarketConfiguration,
-          oraclePricePerMarket,
-          uniqueQuoteTokens,
-        ),
-      );
-    }
-
-    return tokenMarginInfoPerAsset;
-  }
-  static calculateLiquidation(
-    globalMarginInfo: MarginInfo,
-    oraclePrice: number,
-    positionBase: number,
-  ): BigNumber {
-    const liquidationPrice = BigNumber(oraclePrice).minus(
-      BigNumber(globalMarginInfo.marginBalance)
-        .minus(globalMarginInfo.liquidationMarginRequirement)
-        .div(positionBase),
-    );
-
-    return BigNumber.max(0, liquidationPrice);
-  }
-
-  static calculateImpliedLeverage(
-    notionalExposure: number,
-    oldIMR: number,
-    newIMR: number,
-  ): number {
-    const changeInImr = BigNumber(newIMR).minus(oldIMR);
-
-    if (changeInImr.eq(0)) {
-      return 0;
-    }
-    return BigNumber(notionalExposure).div(changeInImr).toNumber();
-  }
-
-  static combineMarginInfo(
-    parentMarginInfo: MarginInfo,
-    sonMarginInfo: MarginInfo,
-    sonParentExchangeInfo: ExchangeInfo,
-  ): MarginInfo {
-    return {
-      assetAddress: parentMarginInfo.assetAddress,
-      marginBalance: BigNumber(parentMarginInfo.marginBalance)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            sonMarginInfo.marginBalance,
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      realBalance: BigNumber(parentMarginInfo.realBalance)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            sonMarginInfo.realBalance,
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      initialDelta: BigNumber(parentMarginInfo.initialDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.realBalance,
-              sonMarginInfo.initialDelta,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      maintenanceDelta: BigNumber(parentMarginInfo.maintenanceDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.maintenanceDelta,
-              sonMarginInfo.realBalance,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      liquidationDelta: BigNumber(parentMarginInfo.liquidationDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.liquidationDelta,
-              sonMarginInfo.realBalance,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      dutchDelta: BigNumber(parentMarginInfo.dutchDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.dutchDelta,
-              sonMarginInfo.realBalance,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      adlDelta: BigNumber(parentMarginInfo.adlDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.adlDelta,
-              sonMarginInfo.realBalance,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-
-      initialBufferDelta: BigNumber(parentMarginInfo.initialBufferDelta)
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            BigNumber.min(
-              sonMarginInfo.initialBufferDelta,
-              sonMarginInfo.realBalance,
-            ).toNumber(),
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-      liquidationMarginRequirement: BigNumber(
-        parentMarginInfo.liquidationMarginRequirement,
-      )
-        .plus(
-          ExposureCommand.exchangeWithPriceHaircut(
-            sonMarginInfo.liquidationMarginRequirement,
-            sonParentExchangeInfo.price,
-            sonParentExchangeInfo.priceHaircut,
-          ),
-        )
-        .toNumber(),
-    };
-  }
-
-  static getUsdNodeMarginInfo(
-    accountCollateralPoolId: number,
-    quoteTokens: string[],
-    exchangeInfoPerAsset: ExchangeInfo[],
-    marginInfoPerToken: MarginInfo[],
-  ) {
-    let usdNodeMarginInfo: MarginInfo = {
-      assetAddress: '',
-      marginBalance: 0,
-      realBalance: 0,
-      initialDelta: 0,
-      maintenanceDelta: 0,
-      liquidationDelta: 0,
-      dutchDelta: 0,
-      adlDelta: 0,
-      initialBufferDelta: 0,
-      liquidationMarginRequirement: 0,
-    };
-    for (const quoteToken of quoteTokens) {
-      const exchangeInfo = exchangeInfoPerAsset.find((exchangeInfo) => {
-        return quoteToken === exchangeInfo.tokenAddress;
-      });
-
-      const marginInfo = marginInfoPerToken.find((marginInfo) => {
-        return quoteToken === marginInfo.assetAddress;
-      });
-
-      if (!exchangeInfo || !marginInfo) {
-        throw Error('Missing exchangeInfo/marginInfo');
-      }
-
-      usdNodeMarginInfo = ExposureCommand.combineMarginInfo(
-        usdNodeMarginInfo,
-        marginInfo,
-        exchangeInfo,
-      );
-    }
-
-    return usdNodeMarginInfo;
-  }
-  static getCollateralInfo(
-    collateralAddress: string,
-    realisedPnl: BigNumber,
-    unrealizedPnL: BigNumber,
-    netDeposits: number,
-  ): CollateralInfo {
-    return {
-      netDeposits: netDeposits,
-      marginBalance: BigNumber(netDeposits)
-        .plus(realisedPnl)
-        .plus(unrealizedPnL)
-        .toNumber(),
-      realBalance: BigNumber(netDeposits).plus(realisedPnl).toNumber(),
-    };
-  }
-
-  static getTokenMarginInfo(
-    rootCollateralPoolId: number,
-    riskMatrices: RiskMatrix[],
-    riskMultipliers: RiskMultipliersConfiguration,
-    collateralInfo: CollateralInfo,
-    collateralAddress: string,
-    positions: PositionInfoMarketConfiguration[],
-    oraclePricePerMarket: MarketIdToOraclePriceMap,
-    uniqueQuoteTokens: string[],
-  ): MarginInfo {
-    const marginRequirements = {
-      liquidationMarginRequirement: 0,
-      initialMarginRequirement: 0,
-      maintenanceMarginRequirement: 0,
-      dutchMarginRequirement: 0,
-      adlMarginRequirement: 0,
-      initialBufferMarginRequirement: 0,
-    };
-    if (uniqueQuoteTokens.includes(collateralAddress)) {
-      // uniqueQuoteTokens is list is active markets tokens
-      for (const riskMatrix of riskMatrices) {
-        if (Number(riskMatrix.risk_block_id) === 1) continue; // @todo remove and implement correct logic!
-        const filledExposures = ExposureCommand.getBlockExposures(
-          positions,
-          oraclePricePerMarket,
-        );
-
-        marginRequirements.liquidationMarginRequirement = BigNumber(
-          marginRequirements.liquidationMarginRequirement,
-        )
-          .plus(
-            ExposureCommand.computeLiquidationMarginRequirement(
-              riskMatrix.matrix,
-              filledExposures,
-            ),
-          )
-          .toNumber();
-      }
-
-      // Get the initial margin requirement
-      marginRequirements.initialMarginRequirement = amountNormalizer(
-        String(riskMultipliers.im_multiplier),
-      )
-        .multipliedBy(marginRequirements.liquidationMarginRequirement)
-        .toNumber();
-      // Get the maintenance margin requirement
-      marginRequirements.maintenanceMarginRequirement = amountNormalizer(
-        String(riskMultipliers.mmr_multiplier),
-      )
-        .multipliedBy(marginRequirements.liquidationMarginRequirement)
-        .toNumber();
-      // Get the dutch margin requirement
-      marginRequirements.dutchMarginRequirement = amountNormalizer(
-        String(riskMultipliers.dutch_multiplier),
-      )
-        .multipliedBy(marginRequirements.liquidationMarginRequirement)
-        .toNumber();
-
-      // Get the adl margin requirement
-      marginRequirements.adlMarginRequirement = amountNormalizer(
-        String(riskMultipliers.adl_multiplier),
-      )
-        .multipliedBy(marginRequirements.liquidationMarginRequirement)
-        .toNumber();
-
-      // Get the initial buffer margin requirement
-      marginRequirements.initialBufferMarginRequirement = amountNormalizer(
-        String(riskMultipliers.im_buffer_multiplier),
-      )
-        .multipliedBy(marginRequirements.liquidationMarginRequirement)
-        .toNumber();
-    }
-    return {
-      assetAddress: collateralAddress,
-      marginBalance: collateralInfo.marginBalance,
-      realBalance: collateralInfo.realBalance,
-      initialDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.initialMarginRequirement)
-        .toNumber(),
-      maintenanceDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.maintenanceMarginRequirement)
-        .toNumber(),
-      liquidationDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.liquidationMarginRequirement)
-        .toNumber(),
-      dutchDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.dutchMarginRequirement)
-        .toNumber(),
-      adlDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.adlMarginRequirement)
-        .toNumber(),
-      initialBufferDelta: BigNumber(collateralInfo.marginBalance)
-        .minus(marginRequirements.initialBufferMarginRequirement)
-        .toNumber(),
-      liquidationMarginRequirement:
-        marginRequirements.liquidationMarginRequirement,
-    };
-  }
-
-  static computeLiquidationMarginRequirement(
-    matrix: BigNumber[][],
-    filledExposures: BigNumber[],
-  ): number {
-    let lmrFilledSquared = 0;
-
-    for (let i = 0; i < filledExposures.length; i++) {
-      if (BigNumber(filledExposures[i]).eq(0)) {
-        continue;
-      }
-      for (let j = 0; j < filledExposures.length; j++) {
-        const riskParam = matrix[i][j];
-
-        if (BigNumber(filledExposures[j]).eq(0) || BigNumber(riskParam).eq(0)) {
-          continue;
-        }
-
-        lmrFilledSquared = BigNumber(lmrFilledSquared)
-          .plus(
-            BigNumber(filledExposures[i])
-              .multipliedBy(filledExposures[j])
-              .multipliedBy(riskParam),
-          )
-          .toNumber();
-      }
-    }
-    return BigNumber(lmrFilledSquared).sqrt().toNumber();
-  }
-
-  static getBlockExposures(
-    positions: PositionInfoMarketConfiguration[],
-    oraclePricePerMarket: MarketIdToOraclePriceMap,
-  ): BigNumber[] {
-    const filledExposures: number[] = [];
-
-    for (const position of positions) {
-      const marketFilledExposure = ExposureCommand.getAccountFilledExposures(
-        position,
-        position.market_configuration,
-        oraclePricePerMarket[position.market_id],
-      );
-      filledExposures[marketFilledExposure.riskMatrixIndex] = BigNumber(
-        filledExposures[marketFilledExposure.riskMatrixIndex] || 0,
-      )
-        .plus(marketFilledExposure.exposure)
-        .toNumber();
-    }
-
-    return filledExposures.map((num) => BigNumber(num));
-  }
-
-  static getAccountFilledExposures(
-    position: PositionInfo,
-    marketConfiguration: MarketConfiguration,
-    oraclePrice: number,
-  ) {
-    const base = position.base;
-
-    return {
-      exposure: BigNumber(oraclePrice).multipliedBy(base),
-      riskMatrixIndex: BigNumber(
-        String(marketConfiguration.risk_matrix_index),
-      ).toNumber(),
-    };
-  }
-
-  static computePricePnL(
-    openBase: BigNumber,
-    openPrice: BigNumber,
-    exitPrice: BigNumber,
-  ) {
-    return BigNumber(
-      BigNumber(exitPrice).minus(openPrice).multipliedBy(openBase),
-    );
-  }
-
-  static getMarginRatio(marginInfo: MarginInfo) {
-    if (marginInfo.liquidationMarginRequirement === 0) {
-      return 0;
-    }
-
-    if (marginInfo.marginBalance <= 0) {
-      return 1;
-    }
-
-    const health = BigNumber(marginInfo.liquidationMarginRequirement).div(
-      marginInfo.marginBalance,
-    );
-
-    if (health.gt(1)) {
-      return 1;
-    }
-    return health.toNumber();
-  }
-
-  static exchangeWithPriceHaircut(
-    quantity: number,
-    price: number,
-    haircut: number,
-  ) {
-    // For positive quantities, the haircut is `quantity * (1 - haircut)`
-    // For negative values, the haircut is `quantity / (1 - haircut)` because a negative value means the haircut should be applied from B to A.
-    const calHelper = BigNumber(quantity).gt(0)
-      ? BigNumber(1).minus(haircut)
-      : BigNumber(1).div(BigNumber(1).minus(haircut));
-    const haircutPrice = BigNumber(price).multipliedBy(calHelper);
-
-    return haircutPrice.multipliedBy(quantity).toNumber();
-  }
-
-  getSlippage(
-    deltaBase: number,
-    marketConfiguration: MarketConfiguration,
-    marketStorage: MarketStorage,
-  ): number {
-    const deltaExposure = BigNumber(
-      this.oraclePricePerMarket[marketConfiguration.market_id],
-    )
-      .times(deltaBase)
-      .toNumber();
-
-    const riskMatrixIndex = BigNumber(
-      String(marketConfiguration.risk_matrix_index),
-    ).toNumber();
-
-    const { maxExposureShort, maxExposureLong, exposures } =
-      this.getMaxExposure(marketConfiguration, marketStorage);
-
-    const netExposure = exposures[riskMatrixIndex].plus(deltaExposure);
-    const maxExposure = netExposure.lt(0) ? maxExposureShort : maxExposureLong;
-
-    return BigNumber(netExposure)
-      .negated()
-      .div(BigNumber(maxExposure).plus(netExposure))
-      .toNumber();
-  }
-
-  getMaxExposure(
-    marketConfiguration: MarketConfiguration,
-    marketStorage: MarketStorage,
-  ) {
-    const riskMatrix = this.riskMatrices.find((riskMatrix) => {
-      return (
-        riskMatrix.risk_block_id ===
-        BigNumber(String(marketStorage.risk_block_id)).toNumber()
-      );
-    });
-
-    if (!riskMatrix) {
-      throw new Error("RiskMatrix Doesn't exist");
-    }
-
-    const riskMatrixIndex = BigNumber(
-      String(marketConfiguration.risk_matrix_index),
-    ).toNumber();
-
-    const imrMultiplier = amountNormalizer(
-      String(this.riskMultipliers.im_multiplier),
-    ).toNumber();
-
-    const marginInfo = this.tokenMarginInfoPerAsset.find((marginInfo) => {
-      return marginInfo.assetAddress === marketStorage.quote_collateral;
-    });
-
-    if (!marginInfo) {
-      throw new Error("marginInfo doesn't exist");
-    }
-
-    const exposures = ExposureCommand.getBlockExposures(
-      this.positionInfoMarketConfiguration,
-      this.oraclePricePerMarket,
-    );
-
-    const { maxExposureShort, maxExposureLong } =
-      ExposureCommand.computeMaxExposures(
-        riskMatrix.matrix,
-        exposures,
-        marginInfo.liquidationMarginRequirement,
-        marginInfo.marginBalance < 0 ? 0 : marginInfo.marginBalance,
-        imrMultiplier,
-        riskMatrixIndex,
-      );
-
-    return {
-      maxExposureShort,
-      maxExposureLong,
-      exposures,
-    };
-  }
-
-  static computeMaxExposures(
-    riskMatrix: BigNumber[][],
-    exposures: BigNumber[],
-    lmr: number,
-    balance: number,
-    imrMultiplier: number,
-    exposureIndex: number,
-  ) {
-    let b = BigNumber(0);
-
-    for (let i = 0; i < exposures.length; i++) {
-      b = BigNumber(b).plus(
-        BigNumber(exposures[i]).multipliedBy(
-          BigNumber(riskMatrix[exposureIndex][i]).plus(
-            riskMatrix[i][exposureIndex],
-          ),
-        ),
-      );
-    }
-    const { x1, x2 } = this.solveQuadraticEquation(
-      BigNumber(riskMatrix[exposureIndex][exposureIndex]).toNumber(), // changes here
-      b.toNumber(),
-      this.computeC(lmr, balance, imrMultiplier),
-    );
-
-    const maxShortExposure = BigNumber(x1).plus(exposures[exposureIndex]);
-    const maxLongExposure = BigNumber(x2).plus(exposures[exposureIndex]);
-
-    const availableShortExposure = maxShortExposure.lt(0)
-      ? maxShortExposure.negated().toNumber()
-      : 0;
-
-    const availableLongExposure = maxLongExposure.gt(0)
-      ? maxLongExposure.toNumber()
-      : 0;
-
-    return {
-      maxExposureShort: availableShortExposure,
-      maxExposureLong: availableLongExposure,
-    };
-  }
-
-  static solveQuadraticEquation(a: number, b: number, c: number) {
-    if (BigNumber(a).eq(0)) {
-      throw new Error('ZeroQuadraticCoefficient');
-    }
-
-    const delta = BigNumber(b)
-      .multipliedBy(b)
-      .minus(BigNumber(4).multipliedBy(a).multipliedBy(c));
-
-    if (delta.lt(0)) {
-      throw new Error('ComplexQuadraticRoots(a, b, c)');
-    }
-
-    const rootDelta = delta.sqrt();
-
-    const x1 = BigNumber(b)
-      .multipliedBy(-1)
-      .minus(rootDelta)
-      .div(BigNumber(2).multipliedBy(a));
-
-    const x2 = BigNumber(b)
-      .multipliedBy(-1)
-      .plus(rootDelta)
-      .div(BigNumber(2).multipliedBy(a));
-
-    return {
-      x1,
-      x2,
-    };
-  }
-
-  static computeC(lmr: number, balance: number, imrMultiplier: number): number {
-    const lmrSD = BigNumber(lmr);
-    const lmrSquared = lmrSD.multipliedBy(lmrSD);
-
-    const balanceSD = BigNumber(balance);
-    const balanceSquared = balanceSD.multipliedBy(balanceSD);
-
-    const imrMultiplierSD = BigNumber(imrMultiplier);
-    const imrMultiplierSquared = imrMultiplierSD.multipliedBy(imrMultiplierSD);
-
-    return lmrSquared
-      .minus(balanceSquared.div(imrMultiplierSquared))
-      .toNumber();
-  }
-
-  static calculateFee(
-    price: number,
-    amount: number,
-    feeParameter: BigNumber,
-  ): number {
-    return BigNumber(price).times(amount).times(feeParameter).abs().toNumber(); // @todo abs value
-  }
-
-  static calculateEstimatedPrice(price: number, slippage: number): number {
-    return BigNumber(price).times(BigNumber(1).plus(slippage)).toNumber();
-  }
-
-  static evaluateHealthStatus(number: number) {
-    // todo update logic
-    if (number >= 67) {
-      return 'danger';
-    } else if (number >= 34) {
-      return 'warning';
-    } else {
-      return 'healthy';
-    }
-  }
-}