@reyaxyz/api-sdk 0.18.0 → 0.18.1

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

@@ -0,0 +1,792 @@
+import BigNumber from 'bignumber.js';
+import {
+  AccountAssetBalance,
+  CollateralInfo,
+  ExchangeInfo,
+  ExposureCommandState,
+  MarginInfo,
+  MarketConfiguration,
+  MarketStorage,
+  PositionInfo,
+  PositionInfoMarketConfiguration,
+  RiskMatrix,
+  RiskMultipliersConfiguration,
+} from './trade.simulation.types';
+import { amountNormalizer } from './number';
+
+export class ExposureCommand {
+  rootCollateralPoolId: number;
+  oraclePrice: number;
+  rate: number;
+  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,
+    oraclePrice: number,
+    rate: number,
+    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.oraclePrice = oraclePrice;
+    this.rate = rate;
+    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,
+      oraclePrice: this.oraclePrice,
+      rate: this.rate,
+      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;
+  }
+
+  getUsdNodeMarginInfoPostTrade(
+    positionAmount: number,
+    collateralAddress: string,
+    marketConfiguration: MarketConfiguration,
+  ) {
+    const positionInfoMarketConfiguration = [
+      ...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.oraclePrice,
+      );
+
+    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[],
+    oraclePrice: number,
+  ) {
+    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,
+          oraclePrice,
+        ),
+      );
+    }
+
+    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[],
+    oraclePrice: number,
+  ): MarginInfo {
+    const marginRequirements = {
+      liquidationMarginRequirement: 0,
+      initialMarginRequirement: 0,
+      maintenanceMarginRequirement: 0,
+      dutchMarginRequirement: 0,
+      adlMarginRequirement: 0,
+      initialBufferMarginRequirement: 0,
+    };
+
+    for (const riskMatrix of riskMatrices) {
+      const filledExposures = ExposureCommand.getBlockExposures(
+        positions,
+        oraclePrice,
+      );
+
+      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[],
+    oraclePrice: number,
+  ): BigNumber[] {
+    const filledExposures: number[] = [];
+
+    for (const position of positions) {
+      const marketFilledExposure = ExposureCommand.getAccountFilledExposures(
+        position,
+        position.market_configuration,
+        oraclePrice,
+      );
+      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.oraclePrice)
+      .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.oraclePrice,
+    );
+
+    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';
+    }
+  }
+}