@reyaxyz/api-sdk 0.18.0 → 0.18.1

package/src/clients/helpers/number.ts

@@ -0,0 +1,8 @@
+import BigNumber from 'bignumber.js';
+
+export function amountNormalizer(
+  value: BigNumber | number | string,
+  decimals: number = 18,
+): BigNumber {
+  return BigNumber(value).div(BigNumber(10).pow(decimals));
+}

package/src/clients/helpers/trade.simulation.types.ts

@@ -0,0 +1,115 @@
+import BigNumber from 'bignumber.js';
+
+export interface MarketStorage {
+  market_id: number;
+  quote_collateral: string;
+  instrument_address: string;
+  name: string;
+  risk_block_id: number;
+  collateral_pool_id: number;
+  block_timestamp: number;
+  block_number: number;
+}
+
+export interface MarketConfiguration {
+  market_id: number;
+  risk_matrix_index: number;
+  max_open_interest: number;
+  oracle_node_id: string;
+  mtm_window: number;
+  dutch_config_lambda: number;
+  dutch_config_min_base: number;
+  slippage_params_phi: number;
+  slippage_params_beta: number;
+  block_timestamp: number;
+  block_number: number;
+}
+
+export type AccountAssetBalance = {
+  accountId: number;
+  collateral: string;
+  amount: number;
+};
+
+export interface RiskMultipliersConfiguration {
+  collateral_pool_id: number;
+  im_multiplier: number;
+  mmr_multiplier: number;
+  dutch_multiplier: number;
+  adl_multiplier: number;
+  im_buffer_multiplier: number;
+  block_timestamp: number;
+  block_number: number;
+}
+
+export interface RiskMatrix {
+  collateral_pool_id: number;
+  risk_block_id: number;
+  matrix: BigNumber[][];
+}
+
+export interface ExchangeInfo {
+  price: number;
+  priceHaircut: number;
+  autoExchangeDiscount: number;
+  tokenAddress: string;
+}
+
+export interface PositionInfo {
+  base: BigNumber;
+  realized_pnl: BigNumber;
+  last_price: BigNumber;
+  last_timestamp: BigNumber;
+  funding_value: BigNumber;
+  base_multiplier: BigNumber;
+  adl_unwind_price: BigNumber;
+  market_id: number;
+}
+
+export type PositionInfoMarketConfiguration = PositionInfo & {
+  market_configuration: MarketConfiguration;
+};
+
+export interface MarginInfo {
+  assetAddress: string;
+  marginBalance: number;
+  realBalance: number;
+  initialDelta: number;
+  maintenanceDelta: number;
+  liquidationDelta: number;
+  dutchDelta: number;
+  adlDelta: number;
+  initialBufferDelta: number;
+  liquidationMarginRequirement: number;
+}
+
+export interface CollateralInfo {
+  netDeposits: number;
+  marginBalance: number;
+  realBalance: number;
+}
+
+export type ExposureCommandState = {
+  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;
+};
+
+export type TradeSimulationState = {
+  feeParameter: BigNumber;
+  marketStorage: MarketStorage;
+  marketConfiguration: MarketConfiguration;
+  exposureDataAccount: ExposureCommandState;
+  exposureDataPassivePool: ExposureCommandState;
+};

package/src/clients/modules/account.ts

@@ -9,8 +9,10 @@ import {
   GetPositionsForMarginAccountResult,
   GetPositionsHistoryForMarginAccountParams,
   GetPositionsHistoryForMarginAccountResult,
+  GetTransactionSimulationInitialDataParams,
 } from '../types';
 import RestClient from './rest';
+import { TradeSimulationState } from '../helpers/trade.simulation.types';
 
 export default class AccountClient extends RestClient {
   /**
@@ -75,4 +77,13 @@ export default class AccountClient extends RestClient {
       direction: params.direction,
     });
   }
+
+  async getTransactionSimulationInitialData(
+    params: GetTransactionSimulationInitialDataParams,
+  ): Promise<TradeSimulationState> {
+    const uri = `/api/accounts/${params.marginAccountId}/trade-simulation-data`;
+    return this.get(uri, {
+      marketId: params.marketId,
+    });
+  }
 }

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

@@ -3,56 +3,37 @@ import {
   TradeSimulationLoadDataParams,
   TradeSimulationSimulateParams,
 } from '../types';
-
-type LoadedData = {
-  marketData: number;
-};
-
-// The maximum is inclusive and the minimum is inclusive
-function getRandomIntInclusive(min: number, max: number) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  return Math.floor(Math.random() * (max - min + 1) + min);
-}
-
-const randomHealth = () => {
-  return Math.random() * 100 > 50
-    ? 'healthy'
-    : Math.random() * 100 > 50
-      ? 'danger'
-      : 'warning';
-};
-
-function getRandomFloat(min: number, max: number): number {
-  return Math.random() * (max - min) + min;
-}
+import AccountClient from './account';
+import { TradeSimulationState } from '../helpers/trade.simulation.types';
+import { ExposureCommand } from '../helpers/exposure.calculator';
+import BigNumber from 'bignumber.js';
 
 export default class TradeSimulationClient {
   private marketId: number | null = null;
   private accountId: number | null = null;
-  private loadedData: LoadedData | null = null;
+  private loadedData: TradeSimulationState | 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;
 
-    // Simulate fetching data (@todo replace this with actual data fetching logic)
-    const marketData = await this.fetchMarketData(
-      this.marketId,
-      this.accountId,
-    );
-
-    // Store the loaded data
-    this.loadedData = { marketData };
+    this.loadedData = await this.fetchMarketData(this.marketId, this.accountId);
   }
 
   private async fetchMarketData(
     marketId: number,
     accountId: number,
-  ): Promise<number> {
-    await new Promise((resolve) => setTimeout(resolve, 500)); // wait for 500ms
-    return 1 + marketId + accountId;
+  ): Promise<TradeSimulationState> {
+    return this.accountClient.getTransactionSimulationInitialData({
+      marginAccountId: accountId,
+      marketId: marketId,
+    });
   }
 
   // Synchronous method to simulate operations based on an amount
@@ -61,17 +42,95 @@ export default class TradeSimulationClient {
       throw new Error('Data not loaded. Call arm() first.');
     }
 
-    // @todo perform simulation
+    const amount = BigNumber(params.amount)
+      .div(this.loadedData.exposureDataAccount.oraclePrice)
+      .toNumber();
+
+    const userAccountExposure = new ExposureCommand(
+      this.loadedData.exposureDataAccount.rootCollateralPoolId,
+      this.loadedData.exposureDataAccount.oraclePrice,
+      this.loadedData.exposureDataAccount.rate,
+      this.loadedData.exposureDataAccount.accountBalancePerAsset,
+      this.loadedData.exposureDataAccount.groupedByCollateral,
+      this.loadedData.exposureDataAccount.riskMultipliers,
+      this.loadedData.exposureDataAccount.riskMatrices,
+      this.loadedData.exposureDataAccount.exchangeInfoPerAsset,
+      this.loadedData.exposureDataAccount.positionInfoMarketConfiguration,
+      this.loadedData.exposureDataAccount.uniqueTokenAddresses,
+      this.loadedData.exposureDataAccount.uniqueQuoteCollaterals,
+      this.loadedData.exposureDataAccount.tokenMarginInfoPerAsset,
+      this.loadedData.exposureDataAccount.realizedPnLSum,
+      this.loadedData.exposureDataAccount.unrealizedPnLSum,
+    );
+
+    const passivePoolExposure = new ExposureCommand(
+      this.loadedData.exposureDataPassivePool.rootCollateralPoolId,
+      this.loadedData.exposureDataPassivePool.oraclePrice,
+      this.loadedData.exposureDataPassivePool.rate,
+      this.loadedData.exposureDataPassivePool.accountBalancePerAsset,
+      this.loadedData.exposureDataPassivePool.groupedByCollateral,
+      this.loadedData.exposureDataPassivePool.riskMultipliers,
+      this.loadedData.exposureDataPassivePool.riskMatrices,
+      this.loadedData.exposureDataPassivePool.exchangeInfoPerAsset,
+      this.loadedData.exposureDataPassivePool.positionInfoMarketConfiguration,
+      this.loadedData.exposureDataPassivePool.uniqueTokenAddresses,
+      this.loadedData.exposureDataPassivePool.uniqueQuoteCollaterals,
+      this.loadedData.exposureDataPassivePool.tokenMarginInfoPerAsset,
+      this.loadedData.exposureDataPassivePool.realizedPnLSum,
+      this.loadedData.exposureDataPassivePool.unrealizedPnLSum,
+    );
+
+    const slippage = passivePoolExposure.getSlippage(
+      amount,
+      this.loadedData.marketConfiguration,
+      this.loadedData.marketStorage,
+    );
+    const estimatedPrice = ExposureCommand.calculateEstimatedPrice(
+      this.loadedData.exposureDataPassivePool.oraclePrice,
+      slippage,
+    );
+    const fees = ExposureCommand.calculateFee(
+      this.loadedData.exposureDataAccount.oraclePrice,
+      amount,
+      this.loadedData.feeParameter,
+    );
+
+    const oldMarginInfo = userAccountExposure.getUsdNodeMarginInfo;
+
+    const newMarginInfo = userAccountExposure.getUsdNodeMarginInfoPostTrade(
+      amount,
+      this.loadedData.marketStorage.quote_collateral,
+      this.loadedData.marketConfiguration,
+    );
+
+    const impliedLeverage = ExposureCommand.calculateImpliedLeverage(
+      amount * this.loadedData.exposureDataAccount.oraclePrice,
+      oldMarginInfo.marginBalance - oldMarginInfo.initialDelta,
+      newMarginInfo.marginBalance - newMarginInfo.initialDelta,
+    );
+
+    const postTradeImr =
+      newMarginInfo.marginBalance - newMarginInfo.initialDelta;
+
+    const liquidationPrice = ExposureCommand.calculateLiquidation(
+      newMarginInfo,
+      this.loadedData.exposureDataAccount.oraclePrice,
+      amount,
+    );
+
+    const marginRatio = ExposureCommand.getMarginRatio(newMarginInfo);
+
+    const marginRatioHealth = ExposureCommand.evaluateHealthStatus(marginRatio);
 
     return {
-      estimatedPrice: getRandomIntInclusive(1000, 100000) + params.amount,
-      estimatedSlippage: getRandomFloat(0.00001, 0.05),
-      fees: getRandomIntInclusive(1000, 100000),
-      impliedLeverage: getRandomIntInclusive(20, 50),
-      imr: getRandomIntInclusive(1000, 100000),
-      liquidationPrice: getRandomIntInclusive(1000, 100000),
-      marginRatio: getRandomIntInclusive(0, 100),
-      marginRatioHealth: randomHealth(),
+      estimatedPrice: estimatedPrice,
+      estimatedSlippage: slippage,
+      fees: fees,
+      impliedLeverage: impliedLeverage,
+      imr: postTradeImr,
+      liquidationPrice: liquidationPrice.toNumber(),
+      marginRatio: marginRatio,
+      marginRatioHealth: marginRatioHealth,
     } as SimulateTradeEntity;
   }
 }

package/src/clients/types.ts

@@ -10,6 +10,7 @@ export enum CandlesResolution {
 
 // -- Candles --
 export interface Candle {
+  id: string;
   startedAt: string;
   ticker: string;
   resolution: CandlesResolution;
@@ -21,7 +22,6 @@ export interface Candle {
   usdVolume: string;
   trades: number;
   startingOpenInterest: string;
-  id: string;
 }
 
 export interface MarketCandlesResponse {
@@ -275,3 +275,10 @@ export type GetLpPoolWithdrawBalanceParams = {
 };
 
 export type GetLpPoolWithdrawBalanceResult = number;
+
+// ---- Transaction Simulation ----
+
+export type GetTransactionSimulationInitialDataParams = {
+  marketId: MarketEntity['id'];
+  marginAccountId: MarginAccountEntity['id'];
+};

package/src/index.ts

@@ -1,2 +1,4 @@
 export { ApiClient } from './clients/api-client';
 export * from './clients/types';
+export * from './clients/helpers/exposure.calculator';
+export * from './clients/helpers/trade.simulation.types';