@reyaxyz/common 0.364.1 → 0.364.3

package/src/commands/exposure/command.ts

@@ -1,26 +1,21 @@
 import BigNumber from 'bignumber.js';
-import cloneDeep from 'lodash.clonedeep';
 import {
   AccountAssetBalance,
   CollateralAddressToExchangePriceMap,
   CollateralInfo,
   ExchangeInfo,
-  ExposureCommandState,
   MarginInfo,
   MarketConfiguration,
   MarketIdToOraclePriceMap,
-  MarketStorage,
   PositionInfo,
   PositionInfoMarketConfiguration,
   RiskMatrix,
   RiskMultipliersConfiguration,
-  EditCollateralAction,
 } from './types';
 import {
   amountNormalizer,
   MA_HEALTH_DANGER_THRESHOLD,
   MA_HEALTH_WARNING_THRESHOLD,
-  POOL_IMR,
 } from '../../utils';
 
 export const MAX_FUNDING_RATE = BigNumber('0.07');
@@ -101,27 +96,6 @@ export class ExposureCommand {
     this.collateralAddressToExchangePrice = collateralAddressToExchangePrice;
   }
 
-  getState(): ExposureCommandState {
-    return {
-      accountId: this.accountId,
-      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,
-      mtmRpnlSum: this.mtmRpnlSum,
-      collateralAddressToExchangePrice: this.collateralAddressToExchangePrice,
-    };
-  }
-
   get getUsdNodeMarginInfo() {
     return ExposureCommand.getUsdNodeMarginInfo(
       this.rootCollateralPoolId,
@@ -134,273 +108,6 @@ export class ExposureCommand {
   get balancePerAsset() {
     return this.tokenMarginInfoPerAsset;
   }
-  get exchangePricePerAsset() {
-    return this.exchangeInfoPerAsset;
-  }
-
-  getUsdNodeMarginInfoPostTrade(
-    positionAmount: number,
-    collateralAddress: string,
-    marketConfiguration: MarketConfiguration,
-    riskBlockId: number,
-  ) {
-    // 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),
-        realized_pnl_with_mtm: BigNumber(0),
-        realized_pnl_latest_snapshot: BigNumber(0),
-        latest_funding_cashflow: BigNumber(0),
-        last_price: BigNumber(0),
-        average_entry_price_off_chain_tracker: BigNumber(0),
-        funding_value_off_chain_tracker: BigNumber(0),
-        average_entry_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(),
-        account_id: this.accountId,
-        market_configuration: marketConfiguration,
-        risk_block_id: riskBlockId,
-      });
-    }
-
-    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 {
-      usdNodeMarginInfo: ExposureCommand.getUsdNodeMarginInfo(
-        this.rootCollateralPoolId,
-        uniqueTokenAddresses,
-        this.exchangeInfoPerAsset,
-        tokenMarginInfoPerAsset,
-      ),
-      tokenMarginInfoPerAsset: tokenMarginInfoPerAsset,
-      positionInfoMarketConfiguration: positionInfoMarketConfiguration,
-    };
-  }
-
-  getEditCollateralActionsToCoverMargin(
-    requiredMargin: number,
-  ): EditCollateralAction[] {
-    /*
-     * Note, this function is implicitely making an assumption that required margin can be covered by
-     * the account without breaching account IMR
-     * */
-    const editCollateralActions: EditCollateralAction[] = [];
-    let marginToCover = requiredMargin;
-
-    const uniqueQuoteCollaterals = new Set(this.uniqueQuoteCollaterals);
-
-    const tokenMarginInfoPerAsset =
-      ExposureCommand.calculateTokenMarginInfoPerAsset(
-        this.groupedByCollateral,
-        this.rootCollateralPoolId,
-        this.riskMatrices,
-        this.riskMultipliers,
-        uniqueQuoteCollaterals,
-        this.realizedPnLSum,
-        this.unrealizedPnLSum,
-        this.positionInfoMarketConfiguration,
-        this.oraclePricePerMarket,
-      );
-
-    // todo: p2: consider prioritising rUSD when looping through token infos & document math in comments
-    for (const tokenInfo of tokenMarginInfoPerAsset) {
-      if (tokenInfo.marginBalance < 0) {
-        continue;
-      }
-
-      // todo: p1: haircut and exchange rate adjustment should not be done for rUSD
-      // does exchangeInfo currently return haircut as zero and price as 1?
-      // todo: p2: can just look at net deposits rather than margin balance for non-rusd as non pnl
-
-      const exchangeInfo = this.exchangeInfoPerAsset.find((exchangeInfo) => {
-        return tokenInfo.assetAddress === exchangeInfo.tokenAddress;
-      });
-
-      if (!exchangeInfo) {
-        throw new Error(
-          'Unable to retrieve exchange info when calculating collaterals needed to cover margin',
-        );
-      }
-
-      const marginBalanceWithHaircutInRUSD =
-        ExposureCommand.exchangeWithPriceHaircut(
-          tokenInfo.marginBalance,
-          exchangeInfo.price,
-          exchangeInfo.priceHaircut,
-        );
-
-      if (marginBalanceWithHaircutInRUSD > marginToCover) {
-        const collateralDelta =
-          -ExposureCommand.reverseExchangeWithPriceHaircut(
-            marginToCover,
-            exchangeInfo.price,
-            exchangeInfo.priceHaircut,
-          );
-        editCollateralActions.push({
-          collateralAddress: tokenInfo.assetAddress,
-          collateralDelta: collateralDelta,
-        });
-        break;
-      } else {
-        editCollateralActions.push({
-          collateralAddress: tokenInfo.assetAddress,
-          collateralDelta: -tokenInfo.marginBalance,
-        });
-        marginToCover = marginToCover - marginBalanceWithHaircutInRUSD;
-      }
-    }
-    return editCollateralActions;
-  }
-
-  getUsdNodeMarginInfoPostEditCollaterals(
-    editCollateralActions: EditCollateralAction[],
-  ) {
-    // todo: check if there's a way to simplify this function & deprecate the single edit collateral sim below as it's a
-    // subset of this function
-
-    // perform deep copy of the object
-    const groupedByCollateral: Record<string, AccountAssetBalance> = cloneDeep(
-      this.groupedByCollateral,
-    );
-
-    const uniqueQuoteCollaterals = new Set(this.uniqueQuoteCollaterals);
-    const uniqueTokenAddresses = [...this.uniqueTokenAddresses];
-
-    // counterfactual update deep copy
-
-    for (const action of editCollateralActions) {
-      if (groupedByCollateral[action.collateralAddress]) {
-        groupedByCollateral[action.collateralAddress] = {
-          ...groupedByCollateral[action.collateralAddress],
-          amount:
-            groupedByCollateral[action.collateralAddress].amount +
-            action.collateralDelta,
-        };
-      } else {
-        groupedByCollateral[action.collateralAddress] = {
-          accountId: this.accountId,
-          collateral: action.collateralAddress,
-          amount: action.collateralDelta,
-        };
-      }
-
-      uniqueQuoteCollaterals.add(action.collateralAddress);
-
-      if (!this.uniqueTokenAddresses.includes(action.collateralAddress)) {
-        uniqueTokenAddresses.push(action.collateralAddress);
-      }
-    }
-
-    const tokenMarginInfoPerAsset =
-      ExposureCommand.calculateTokenMarginInfoPerAsset(
-        groupedByCollateral,
-        this.rootCollateralPoolId,
-        this.riskMatrices,
-        this.riskMultipliers,
-        uniqueQuoteCollaterals,
-        this.realizedPnLSum,
-        this.unrealizedPnLSum,
-        this.positionInfoMarketConfiguration,
-        this.oraclePricePerMarket,
-      );
-
-    return ExposureCommand.getUsdNodeMarginInfo(
-      this.rootCollateralPoolId,
-      uniqueTokenAddresses,
-      this.exchangeInfoPerAsset,
-      tokenMarginInfoPerAsset,
-    );
-  }
-
-  getUsdNodeMarginInfoPostEditCollateral(
-    collateralDelta: number,
-    collateralAddress: string,
-  ) {
-    // perform deep copy of the object
-    const groupedByCollateral: Record<string, AccountAssetBalance> = cloneDeep(
-      this.groupedByCollateral,
-    );
-
-    // counterfactual update deep copy
-    if (groupedByCollateral[collateralAddress]) {
-      groupedByCollateral[collateralAddress] = {
-        ...groupedByCollateral[collateralAddress],
-        amount: groupedByCollateral[collateralAddress].amount + collateralDelta,
-      };
-    } else {
-      groupedByCollateral[collateralAddress] = {
-        accountId: this.accountId,
-        collateral: collateralAddress,
-        amount: collateralDelta,
-      };
-    }
-
-    const uniqueQuoteCollaterals = new Set(this.uniqueQuoteCollaterals);
-    const tokenMarginInfoPerAsset =
-      ExposureCommand.calculateTokenMarginInfoPerAsset(
-        groupedByCollateral,
-        this.rootCollateralPoolId,
-        this.riskMatrices,
-        this.riskMultipliers,
-        uniqueQuoteCollaterals,
-        this.realizedPnLSum,
-        this.unrealizedPnLSum,
-        this.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,
@@ -467,19 +174,6 @@ export class ExposureCommand {
     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,
@@ -871,28 +565,6 @@ export class ExposureCommand {
     return haircutPrice.multipliedBy(quantity).toNumber();
   }
 
-  static reverseExchangeWithPriceHaircut(
-    quantity: number,
-    price: number,
-    haircut: number,
-  ) {
-    /*
-     * this operation takes quantity in rUSD terms, price between collateral token (e.g. weth) and rusd
-     * alongside the haircut between weth and rusd
-     * it then returns a quantity in collateral token terms (e.g. weth) which would return quantity if it were to be
-     * passed through the exchangeWithPriceHaircut function
-     * */
-    // todo: p2: consider abstracting haircut price calculation into separate function as duplciated
-    // 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 BigNumber(quantity).dividedBy(haircutPrice).toNumber();
-  }
-
   static getBalanceWithHaircut(
     exchangeInfoPerAsset: ExchangeInfo[],
     assetAddress: string,
@@ -919,228 +591,6 @@ export class ExposureCommand {
     );
   }
 
-  getMaxExposure(
-    marketConfiguration: MarketConfiguration,
-    marketStorage: MarketStorage,
-    isPool: boolean,
-  ) {
-    // todo: p2: cosider turning this into a hashmap vs. an array so that O(1) access
-    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();
-
-    let imrMultiplier;
-    if (isPool) {
-      imrMultiplier = POOL_IMR;
-    } else {
-      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,
-      BigNumber(String(marketStorage.risk_block_id)).toNumber(),
-    );
-
-    const { maxExposureShort, maxExposureLong } =
-      ExposureCommand.computeMaxExposures(
-        riskMatrix.matrix,
-        exposures,
-        marginInfo.liquidationMarginRequirement,
-        marginInfo.marginBalance < 0 ? 0 : marginInfo.marginBalance,
-        imrMultiplier,
-        riskMatrixIndex,
-      );
-
-    return {
-      maxExposureShort,
-      maxExposureLong,
-      exposures,
-      riskMatrixIndex,
-    };
-  }
-
-  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)) {
-      return {
-        x1: BigNumber(0),
-        x2: BigNumber(0),
-      };
-    }
-
-    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 calculateRebalancingOrderBase({
-    poolBasePreTrade,
-    orderBase,
-  }: {
-    poolBasePreTrade: number;
-    orderBase: number;
-  }): number {
-    if (poolBasePreTrade > 0) {
-      if (orderBase < 0) {
-        return 0;
-      }
-
-      return Math.min(poolBasePreTrade, orderBase);
-    }
-
-    if (orderBase > 0) {
-      return 0;
-    }
-
-    return Math.max(poolBasePreTrade, orderBase);
-  }
-
-  static calculateFee({
-    oraclePrice,
-    poolBasePreTrade,
-    orderBase,
-    feeParameter,
-    rebalancingFeeParameter,
-  }: {
-    oraclePrice: number;
-    poolBasePreTrade: number;
-    orderBase: number;
-    feeParameter: BigNumber;
-    rebalancingFeeParameter: BigNumber;
-  }): {
-    rebalancingFee: number;
-    imbalancingFee: number;
-    fee: number;
-  } {
-    const rebalancingOrderBase = this.calculateRebalancingOrderBase({
-      poolBasePreTrade,
-      orderBase,
-    });
-
-    const imbalancingOrderBase = orderBase - rebalancingOrderBase;
-
-    const imbalancingFee = BigNumber(oraclePrice)
-      .times(imbalancingOrderBase)
-      .times(feeParameter)
-      .abs()
-      .toNumber();
-
-    const rebalancingFee = BigNumber(oraclePrice)
-      .times(rebalancingOrderBase)
-      .times(rebalancingFeeParameter)
-      .abs()
-      .toNumber();
-
-    return {
-      imbalancingFee,
-      rebalancingFee,
-      fee: imbalancingFee + rebalancingFee,
-    };
-  }
-
-  static calculateEstimatedPrice(price: number, slippage: number): number {
-    return BigNumber(price).times(BigNumber(1).plus(slippage)).toNumber();
-  }
-
   static evaluateHealthStatus(marginRatioPercentage: number) {
     if (marginRatioPercentage >= MA_HEALTH_DANGER_THRESHOLD) {
       return 'danger';

package/src/commands/exposure/types.ts

@@ -15,8 +15,6 @@ export interface MarketConfiguration {
   market_id: number;
   risk_matrix_index: number;
   max_open_base: number;
-  /** @deprecated Now sourced from Market.Data (MarketTrackers) */
-  velocity_multiplier: number;
   minimum_order_base: number;
   base_spacing: number;
   price_spacing: number;
@@ -26,7 +24,6 @@ export interface MarketConfiguration {
   dutch_config_min_base: number;
   slippage_params_phi: number;
   slippage_params_beta: number;
-  depth_factor: number;
   block_timestamp: number;
   block_number: number;
 }
@@ -142,12 +139,3 @@ export type TradeSimulationState = {
   exposureDataAccount: ExposureCommandState;
   exposureDataPassivePool: ExposureCommandState;
 };
-
-export type EditCollateralSimulationState = {
-  exposureDataAccount: ExposureCommandState;
-};
-
-export type EditCollateralAction = {
-  collateralDelta: number;
-  collateralAddress: Lowercase<string>;
-};