@reyaxyz/api-sdk 0.157.0 → 0.158.0

package/src/clients/modules/rage-trade/index.ts

@@ -1,38 +0,0 @@
-import {
-  GetRageTradeDailyVolumeForPeriodParams,
-  GetRageTradeDailyVolumeForPeriodResult,
-  GetRageTradeLeaderboardForEpochAndTierResult,
-  GetRageTradeLeaderboardForWalletAddressParams,
-  GetRageTradeLeaderboardForWalletAddressResult,
-  GetRageTradeRewardsPerEpochAndTierParams,
-  GetRageTradeRewardsPerEpochAndTierResult,
-} from './types';
-import { RestClient } from '@reyaxyz/common';
-
-export default class RageTradeClient extends RestClient {
-  async getRewardsPerEpochAndTier(): Promise<GetRageTradeRewardsPerEpochAndTierResult> {
-    const uri = `/api/rage-trade/rewards-per-epoch-and-tier`;
-    return this.get(uri);
-  }
-
-  async getLeaderboardForEpochAndTier(
-    params: GetRageTradeRewardsPerEpochAndTierParams,
-  ): Promise<GetRageTradeLeaderboardForEpochAndTierResult> {
-    const uri = `/api/rage-trade/leaderboard-for-epoch-and-tier/${params.walletAddress}?epochId=${params.epochId}&tierId=${params.tierId}&skip=${params.skip}&limit=${params.limit}`;
-    return this.get(uri);
-  }
-
-  async getLeaderboardDetailsForWalletAddress(
-    params: GetRageTradeLeaderboardForWalletAddressParams,
-  ): Promise<GetRageTradeLeaderboardForWalletAddressResult> {
-    const uri = `/api/rage-trade/leaderboard/${params.walletAddress}`;
-    return this.get(uri);
-  }
-
-  async getDailyVolumeForPeriod(
-    params: GetRageTradeDailyVolumeForPeriodParams,
-  ): Promise<GetRageTradeDailyVolumeForPeriodResult> {
-    const uri = `/api/rage-trade/daily-volume-for-period?timestampFrom=${params.timestampFrom}&timestampTo=${params.timestampTo}`;
-    return this.get(uri);
-  }
-}

package/src/clients/modules/rage-trade/types.ts

@@ -1,91 +0,0 @@
-export type GetRageTradeRewardsPerEpochAndTierResult = {
-  rewards: RageTradeRewards[];
-  collateralTierLimits: RageTradeCollateralTierLimits;
-};
-
-export type RageTradeCollateralTierLimits = {
-  '1': number;
-  '2': number;
-  '3': number;
-  '4': number;
-};
-
-export type RageTradeRewards = {
-  epochId: number;
-  startTimeStamp: number;
-  endTimeStamp: number;
-  competitionName: string;
-  rewards: RageTradeReward[];
-};
-
-export type RageTradeReward = {
-  tierId: number;
-  rewardsPerRank: RageTradeRewardsPerRank;
-};
-
-export type RageTradeRewardsPerRank = {
-  '1': number;
-  '2': number;
-  '3': number;
-  '4': number;
-  '5': number;
-  '6': number;
-  '7': number;
-  '8': number;
-  '9': number;
-  '10': number;
-};
-
-export type GetRageTradeLeaderboardForEpochAndTierResult = {
-  totalCount: number;
-  leaderboard: RageTradeLeaderboard[];
-  maxCollateralAverage: number;
-};
-
-export type RageTradeLeaderboard = {
-  epochId: number;
-  tierId: number;
-  rank: number;
-  address: string;
-  maxCollateral: number;
-  pnl: number;
-  roi: number;
-};
-
-export type GetRageTradeRewardsPerEpochAndTierParams = {
-  epochId: string;
-  tierId: string;
-  skip: number;
-  limit: number;
-  walletAddress: string;
-};
-
-export type GetRageTradeLeaderboardForWalletAddressParams = {
-  walletAddress: string;
-};
-
-export type GetRageTradeLeaderboardForWalletAddressResult = {
-  tierId: number;
-  address: string;
-  rank: number;
-  points: number;
-  pnl: number;
-  roi: number;
-  maxCollateral: number;
-};
-
-export type GetRageTradeDailyVolumeForPeriodParams = {
-  timestampFrom: number;
-  timestampTo: number;
-};
-
-export type GetRageTradeDailyVolumeForPeriodResult = {
-  total: number;
-  data: RageTradeDailyVolumeForPeriodData[];
-};
-
-export type RageTradeDailyVolumeForPeriodData = {
-  dateStartTimestamp: number;
-  dateEndTimestamp: number;
-  total_volume: number;
-};

package/src/clients/modules/trade.simulation/index.ts

@@ -1,534 +0,0 @@
-import {
-  EstimatedPriceParams,
-  EstimatedPriceResult,
-  LimitTradeMaxOrderSizeParams,
-  LimitTradeMaxOrderSizeResult,
-  SimulateLimitTradeEntity,
-  SimulateTradeEntity,
-  TradeSimulationConvertValueEstimatedPriceParams,
-  TradeSimulationConvertValueParams,
-  TradeSimulationConvertValueResult,
-  TradeSimulationLoadDataParams,
-  TradeSimulationSimulateLimitParams,
-  TradeSimulationSimulateParams,
-} from './types';
-import AccountClient from '../account';
-import {
-  amountNormalizer,
-  ExposureCommand,
-  MarginInfo,
-  PositionInfo,
-  TradeSimulationState,
-} from '@reyaxyz/common';
-import BigNumber from 'bignumber.js';
-import { INSTANT_TRADING_RATE_XP } from '@reyaxyz/common';
-import { computeFee } from './utils';
-
-export default class TradeSimulationClient {
-  private marketId: number | null = null;
-  private accountId: number | null = null;
-  private loadedData: {
-    tradeSimulationState: TradeSimulationState;
-    userAccountExposure: ExposureCommand;
-    passivePoolExposure: ExposureCommand;
-  } | null = null;
-  private accountClient: AccountClient;
-
-  constructor(accountClient: AccountClient) {
-    // Constructor added
-    this.accountClient = accountClient;
-  }
-
-  // Method to asynchronously load data based on marketId and accountId
-  async arm(params: TradeSimulationLoadDataParams): Promise<void> {
-    this.marketId = params.marketId;
-    this.accountId = params.marginAccountId;
-
-    const tradeSimulationState = await this.fetchMarketData(
-      this.marketId,
-      this.accountId,
-    );
-
-    const userAccountExposure = new ExposureCommand(
-      tradeSimulationState.exposureDataAccount.accountId,
-      tradeSimulationState.exposureDataAccount.rootCollateralPoolId,
-      tradeSimulationState.exposureDataAccount.oraclePricePerMarket,
-      tradeSimulationState.exposureDataAccount.accountBalancePerAsset,
-      tradeSimulationState.exposureDataAccount.groupedByCollateral,
-      tradeSimulationState.exposureDataAccount.riskMultipliers,
-      tradeSimulationState.exposureDataAccount.riskMatrices,
-      tradeSimulationState.exposureDataAccount.exchangeInfoPerAsset,
-      tradeSimulationState.exposureDataAccount.positionInfoMarketConfiguration,
-      tradeSimulationState.exposureDataAccount.uniqueTokenAddresses,
-      tradeSimulationState.exposureDataAccount.uniqueQuoteCollaterals,
-      tradeSimulationState.exposureDataAccount.tokenMarginInfoPerAsset,
-      tradeSimulationState.exposureDataAccount.realizedPnLSum,
-      tradeSimulationState.exposureDataAccount.unrealizedPnLSum,
-      tradeSimulationState.exposureDataAccount.mtmRpnlSum,
-      tradeSimulationState.exposureDataAccount.collateralAddressToExchangePrice,
-    );
-
-    const passivePoolExposure = new ExposureCommand(
-      tradeSimulationState.exposureDataPassivePool.accountId,
-      tradeSimulationState.exposureDataPassivePool.rootCollateralPoolId,
-      tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket,
-      tradeSimulationState.exposureDataPassivePool.accountBalancePerAsset,
-      tradeSimulationState.exposureDataPassivePool.groupedByCollateral,
-      tradeSimulationState.exposureDataPassivePool.riskMultipliers,
-      tradeSimulationState.exposureDataPassivePool.riskMatrices,
-      tradeSimulationState.exposureDataPassivePool.exchangeInfoPerAsset,
-      tradeSimulationState.exposureDataPassivePool.positionInfoMarketConfiguration,
-      tradeSimulationState.exposureDataPassivePool.uniqueTokenAddresses,
-      tradeSimulationState.exposureDataPassivePool.uniqueQuoteCollaterals,
-      tradeSimulationState.exposureDataPassivePool.tokenMarginInfoPerAsset,
-      tradeSimulationState.exposureDataPassivePool.realizedPnLSum,
-      tradeSimulationState.exposureDataPassivePool.unrealizedPnLSum,
-      tradeSimulationState.exposureDataPassivePool.mtmRpnlSum,
-      tradeSimulationState.exposureDataPassivePool.collateralAddressToExchangePrice,
-    );
-
-    this.loadedData = {
-      tradeSimulationState,
-      userAccountExposure,
-      passivePoolExposure,
-    };
-  }
-
-  private async fetchMarketData(
-    marketId: number,
-    accountId: number,
-  ): Promise<TradeSimulationState> {
-    return this.accountClient.getTransactionSimulationInitialData({
-      marginAccountId: accountId,
-      marketId: marketId,
-    });
-  }
-
-  // Synchronous method to simulate operations based on an amount
-  simulate(params: TradeSimulationSimulateParams): SimulateTradeEntity {
-    if (!this.loadedData || !this.marketId) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState, userAccountExposure, passivePoolExposure } =
-      this.loadedData;
-
-    const oraclePrice =
-      tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-        tradeSimulationState.marketConfiguration.market_id
-      ];
-
-    let amount;
-    if (params.fromBase) {
-      amount = params.amount;
-    } else {
-      amount = BigNumber(params.amount).div(oraclePrice).toNumber();
-    }
-
-    /*
-      max amount of margin in rUSD terms that can be transferred from the source account to the destination account
-      that performs the isolated position trade (PRE TRADE)
-    */
-
-    const availableMargin =
-      userAccountExposure.getUsdNodeMarginInfo.initialDelta;
-
-    const marginBalance =
-      userAccountExposure.getUsdNodeMarginInfo.marginBalance;
-
-    const slippage = passivePoolExposure.getSlippage(
-      BigNumber(amount).negated().toNumber(),
-      tradeSimulationState.marketConfiguration,
-      tradeSimulationState.marketStorage,
-    );
-
-    const estimatedPrice = ExposureCommand.calculateEstimatedPrice(
-      oraclePrice,
-      slippage,
-    );
-
-    const feesV2 = computeFee({
-      tradeSimulationState,
-      marketId: this.marketId,
-      orderBase: amount,
-    });
-
-    const {
-      usdNodeMarginInfo: newMarginInfo,
-      tokenMarginInfoPerAsset,
-      positionInfoMarketConfiguration,
-    } = userAccountExposure.getUsdNodeMarginInfoPostTrade(
-      amount,
-      tradeSimulationState.marketStorage.quote_collateral,
-      tradeSimulationState.marketConfiguration,
-      tradeSimulationState.marketStorage.risk_block_id,
-    );
-
-    const newQuoteTokenMarginInfo = tokenMarginInfoPerAsset.find(
-      (marginInfo: MarginInfo) => {
-        return (
-          marginInfo.assetAddress ===
-          tradeSimulationState.marketStorage.quote_collateral
-        );
-      },
-    );
-
-    const positionInfo = positionInfoMarketConfiguration.find(
-      (positionInfo: PositionInfo) => {
-        return (
-          positionInfo.market_id ===
-          tradeSimulationState.marketConfiguration.market_id
-        );
-      },
-    );
-
-    if (!newQuoteTokenMarginInfo) {
-      throw new Error('Error performing simulation');
-    }
-
-    /*
-     * Note, required margin is the initial margin requirement in rUSD terms of the account after the trade.
-     * margin balance rusd - initial delta rusd = margin balance rusd - (margin balance rusd - imr rusd) = imr rusd
-     * */
-
-    const requiredMargin =
-      newQuoteTokenMarginInfo.marginBalance -
-      newQuoteTokenMarginInfo.initialDelta;
-
-    const liquidationPrice = ExposureCommand.calculateLiquidation(
-      newMarginInfo.marginBalance,
-      newQuoteTokenMarginInfo.liquidationMarginRequirement,
-      oraclePrice,
-      BigNumber(positionInfo?.base || 0).toNumber(),
-    );
-
-    const marginRatio = ExposureCommand.getMarginRatio(newMarginInfo);
-
-    const marginRatioHealth = ExposureCommand.evaluateHealthStatus(
-      marginRatio * 100,
-    );
-
-    const baseSpacing = amountNormalizer(
-      tradeSimulationState.marketConfiguration.base_spacing,
-    ).toNumber();
-
-    const snappedAmountInBase = this.roundToBaseSpacing(amount, baseSpacing);
-    const snappedAmount = snappedAmountInBase * estimatedPrice;
-    const xpEarnRangeMin = Math.round(
-      Math.abs(snappedAmount) / INSTANT_TRADING_RATE_XP,
-    );
-    const xpEarnRangeMax = Math.round(
-      (100 * Math.abs(snappedAmount)) / INSTANT_TRADING_RATE_XP,
-    );
-
-    return {
-      estimatedPrice,
-      estimatedSlippage: slippage * 100,
-      fees: feesV2.fee,
-      takerFeesPercentage: feesV2.feePercentage,
-      feesV2,
-      liquidationPrice: liquidationPrice.toNumber(),
-      marginRatio: marginRatio * 100,
-      marginRatioHealth,
-      marginBalance,
-      availableMargin,
-      requiredMargin,
-      snappedAmount,
-      snappedAmountInBase,
-      xpEarnRange: {
-        min: xpEarnRangeMin,
-        max: xpEarnRangeMax,
-      },
-      maxSlippage: 1,
-    };
-  }
-
-  getRiskMatrixElement(): number {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState } = this.loadedData;
-
-    const riskBlockId = tradeSimulationState.marketStorage.risk_block_id;
-    const riskMatrices = tradeSimulationState.exposureDataAccount.riskMatrices;
-
-    const riskMatrix = riskMatrices.find(
-      (riskMatrix) => riskMatrix.risk_block_id === riskBlockId,
-    );
-
-    if (!riskMatrix) {
-      throw new Error('Risk matrix not found');
-    }
-
-    const riskMatrixIndex =
-      tradeSimulationState.marketConfiguration.risk_matrix_index;
-
-    return Number(riskMatrix.matrix[riskMatrixIndex][riskMatrixIndex]);
-  }
-
-  // Synchronous method to simulate operations based on an amount
-  simulateLimit(
-    params: TradeSimulationSimulateLimitParams,
-  ): SimulateLimitTradeEntity {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState, userAccountExposure } = this.loadedData;
-
-    let amount;
-    if (params.fromBase) {
-      amount = params.amount;
-    } else {
-      amount = BigNumber(params.amount).div(params.triggerPrice).toNumber();
-    }
-
-    const baseSpacing = amountNormalizer(
-      tradeSimulationState.marketConfiguration.base_spacing,
-    ).toNumber();
-
-    const snappedAmountInBase = this.roundToBaseSpacing(amount, baseSpacing);
-    const snappedAmount = snappedAmountInBase * params.triggerPrice;
-
-    const { fee: fees } = ExposureCommand.calculateFee({
-      oraclePrice: params.triggerPrice,
-      orderBase: amount,
-      poolBasePreTrade: 0,
-      feeParameter: tradeSimulationState.feeParameter,
-      rebalancingFeeParameter: BigNumber(0),
-    });
-
-    const marginBalance =
-      userAccountExposure.getUsdNodeMarginInfo.marginBalance;
-
-    const availableMargin =
-      userAccountExposure.getUsdNodeMarginInfo.initialDelta;
-
-    const imrMultiplier = amountNormalizer(
-      String(userAccountExposure.riskMultipliers.im_multiplier),
-    ).toNumber();
-
-    const riskMatrixElement = this.getRiskMatrixElement();
-
-    const accountLMR =
-      userAccountExposure.getUsdNodeMarginInfo.liquidationMarginRequirement;
-    const accountIMR = accountLMR * imrMultiplier;
-
-    const limitOrderLMR =
-      Math.sqrt(riskMatrixElement) * Math.abs(snappedAmount);
-    const limitOrderIMR = limitOrderLMR * imrMultiplier;
-
-    const requiredMargin = accountIMR + limitOrderIMR;
-
-    const liquidationMarginRequirement =
-      userAccountExposure.getUsdNodeMarginInfo.liquidationMarginRequirement +
-      limitOrderLMR;
-
-    const marginRatio = ExposureCommand.getMarginRatio({
-      marginBalance,
-      liquidationMarginRequirement,
-    });
-
-    const marginRatioHealth = ExposureCommand.evaluateHealthStatus(
-      marginRatio * 100,
-    );
-
-    const xpEarnRangeMin = Math.round(
-      Math.abs(snappedAmount) / INSTANT_TRADING_RATE_XP,
-    );
-    const xpEarnRangeMax = Math.round(
-      (100 * Math.abs(snappedAmount)) / INSTANT_TRADING_RATE_XP,
-    );
-
-    return {
-      fees,
-      takerFeesPercentage:
-        BigNumber(tradeSimulationState.feeParameter).toNumber() * 100,
-      snappedAmount,
-      snappedAmountInBase,
-      estimatedPrice: params.triggerPrice,
-      marginRatio: marginRatio * 100,
-      marginRatioHealth,
-      availableMargin,
-      marginBalance,
-      requiredMargin,
-      xpEarnRange: {
-        min: xpEarnRangeMin,
-        max: xpEarnRangeMax,
-      },
-    };
-  }
-
-  getMaxAmountForLimitOrder(
-    params: LimitTradeMaxOrderSizeParams,
-  ): LimitTradeMaxOrderSizeResult {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { userAccountExposure, tradeSimulationState } = this.loadedData;
-
-    const riskMatrixElement = this.getRiskMatrixElement();
-
-    const imrMultiplier = amountNormalizer(
-      String(userAccountExposure.riskMultipliers.im_multiplier),
-    ).toNumber();
-
-    const availableMargin =
-      userAccountExposure.getUsdNodeMarginInfo.initialDelta;
-
-    const maxAmountSize = Math.max(
-      (availableMargin / Math.sqrt(riskMatrixElement) / imrMultiplier) * 0.97, // @todo implement dynamic buffer
-      0,
-    );
-    const maxAmountBase = maxAmountSize / params.triggerPrice;
-
-    const minAmountBase = amountNormalizer(
-      tradeSimulationState.marketConfiguration.minimum_order_base,
-    ).toNumber();
-
-    const minAmountSize = minAmountBase * params.triggerPrice;
-
-    return {
-      maxAmountBase,
-      maxAmountSize,
-      minAmountBase,
-      minAmountSize,
-    };
-  }
-
-  convertValue(
-    params: TradeSimulationConvertValueParams,
-  ): TradeSimulationConvertValueResult {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState } = this.loadedData;
-
-    if (!params.fromBase)
-      return BigNumber(params.amount)
-        .div(
-          tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-            tradeSimulationState.marketConfiguration.market_id
-          ],
-        )
-        .toNumber();
-    else
-      return BigNumber(params.amount)
-        .times(
-          tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-            tradeSimulationState.marketConfiguration.market_id
-          ],
-        )
-        .toNumber();
-  }
-
-  convertValueEstimatedPrice(
-    params: TradeSimulationConvertValueEstimatedPriceParams,
-  ): TradeSimulationConvertValueResult {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState, passivePoolExposure } = this.loadedData;
-
-    const amountForSlippage = params.fromBase
-      ? params.amount
-      : BigNumber(params.amount)
-          .div(
-            tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-              tradeSimulationState.marketConfiguration.market_id
-            ],
-          )
-          .toNumber();
-
-    const slippage = passivePoolExposure.getSlippage(
-      BigNumber(amountForSlippage).negated().toNumber(),
-      tradeSimulationState.marketConfiguration,
-      tradeSimulationState.marketStorage,
-    );
-    const estimatedPrice = ExposureCommand.calculateEstimatedPrice(
-      tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-        tradeSimulationState.marketConfiguration.market_id
-      ],
-      slippage,
-    );
-
-    if (!params.fromBase)
-      return BigNumber(params.amount).div(estimatedPrice).toNumber();
-    else return BigNumber(params.amount).times(estimatedPrice).toNumber();
-  }
-
-  customLeverage(): number | null {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState } = this.loadedData;
-
-    return tradeSimulationState.customLeverage;
-  }
-
-  estimatedPrice(params: EstimatedPriceParams): EstimatedPriceResult {
-    if (!this.loadedData) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState, passivePoolExposure } = this.loadedData;
-
-    const slippage = passivePoolExposure.getSlippage(
-      BigNumber(params.amount).negated().toNumber(),
-      tradeSimulationState.marketConfiguration,
-      tradeSimulationState.marketStorage,
-    );
-
-    const price =
-      tradeSimulationState.exposureDataAccount.oraclePricePerMarket[
-        tradeSimulationState.marketConfiguration.market_id
-      ];
-
-    const estimatedPrice = ExposureCommand.calculateEstimatedPrice(
-      tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-        tradeSimulationState.marketConfiguration.market_id
-      ],
-      slippage,
-    );
-
-    return {
-      estimatedPrice,
-      markPrice: price,
-    };
-  }
-
-  roundToBaseSpacing(amount: number, baseSpacing: number): number {
-    const snappedAmount = BigNumber(amount)
-      .abs()
-      .dividedBy(baseSpacing)
-      .integerValue(BigNumber.ROUND_FLOOR)
-      .multipliedBy(baseSpacing)
-      .toNumber();
-
-    if (amount < 0) {
-      return -snappedAmount;
-    }
-    return snappedAmount;
-  }
-
-  updatePrice(price: number): void {
-    if (!this.loadedData || !this.marketId) {
-      throw new Error('Data not loaded. Call arm() first.');
-    }
-
-    const { tradeSimulationState } = this.loadedData;
-
-    // update price
-    const marketId = this.marketId;
-    tradeSimulationState.exposureDataPassivePool.oraclePricePerMarket[
-      marketId
-    ] = price;
-    tradeSimulationState.exposureDataAccount.oraclePricePerMarket[marketId] =
-      price;
-  }
-}