@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.30

package/src/strategies/vesu-extended-strategy/utils/helper.ts

@@ -9,11 +9,15 @@ import {
   USDC_TOKEN_DECIMALS,
   MAX_LIQUIDATION_RATIO,
 } from "./constants";
+import { VesuConfig } from "./config.runtime";
+import { ExtendedAdapter } from "../../universal-adapters/extended-adapter";
+import { Balance } from "@/modules/ExtendedWrapperSDk";
 import { Web3Number } from "@/dataTypes";
 import { Position } from "@/modules/ExtendedWrapperSDk";
 // import { getAllOpenPositionsExtended } from "../services/extendedService";
 import ExtendedWrapper from "@/modules/ExtendedWrapperSDk";
 import { logger } from "@/utils";
+import { HealthFactorMath } from "@/utils/health-factor-math";
 // import {
 //   calculatePositionOnVesu,
 //   getAssetPrice,
@@ -27,7 +31,7 @@ import { logger } from "@/utils";
  */
 export const returnFormattedAmount = (
   amount: number,
-  toTokenDecimals: number
+  toTokenDecimals: number,
 ) => {
   const formattedAmount =
     "0x" + BigInt(Math.floor(amount * 10 ** toTokenDecimals)).toString(16);
@@ -35,69 +39,63 @@ export const returnFormattedAmount = (
 };
 
 /**
- * calculates the amount to distribute to Extend and Vesu
+ * calculates the amount to distribute to Extended and Vesu
  * Determines how much to allocate to each platform based on leverage calculations
  * @param {number} amount - The total amount to distribute
  * @returns {object} Object containing avnu_amount, extended_amount, and extended_leverage
  */
-export const calculateAmountDistribution = async (
-  amount: number,
-  client: ExtendedWrapper,
-  marketName: string,
-  collateralPrice: number,
-  debtPrice: number,
-  collateralUnits: Web3Number,
-  extendedPosition: Position[] | null
-): Promise<{
-  vesu_amount: Web3Number;
-  extended_amount: Web3Number;
-  extended_leverage: number;
-  vesu_leverage: number;
-}> => {
+export const calculateAmountDistribution = (
+  amountToInvest: number,
+  collateralPrice: number, // in usd
+  collateralUnits: Web3Number, // existing collateral in vesu (e.g. BTC)
+  extendedExposureUsd: Web3Number,
+): {
+  vesuAmount: Web3Number;
+  extendedAmount: Web3Number;
+  extendedLeverage: number;
+  vesuLeverage: number;
+} => {
   try {
-    const extended_leverage = calculateExtendedLevergae();
-    const vesu_leverage = calculateVesuLeverage();
-    if (extendedPosition === null) {
-      logger.error("error getting extended positions");
-      return {
-        vesu_amount: new Web3Number(0, 0),
-        extended_amount: new Web3Number(0, 0),
-        extended_leverage: 0,
-        vesu_leverage: 0,
-      };
-    }
-    const extendedBTCExposure =
-      extendedPosition.length > 0
-        ? new Web3Number(extendedPosition[0].size, WBTC_TOKEN_DECIMALS)
-        : new Web3Number(0, WBTC_TOKEN_DECIMALS);
-    const extendedExposureUSD =
-      extendedBTCExposure.multipliedBy(collateralPrice);
+    /**
+     * Logic: Match the newly created total exposure in USD on both sides
+     * New Vesu exposure = VesuAmount * vesuLeverage
+     * New Extended exposure = ExtendedAmount * extendedLeverage
+     * VesuAmount + ExtendedAmount = amountToInvest
+     * ExtendedAmount * extendedleverage = (amountToInvest - ExtendedAmount) * vesuLeverage
+     * ExtendedAmount * (extendedleverage + vesuLeverage) = amountToInvest * vesuLeverage
+     * ExtendedAmount = amountToInvest * vesuLeverage / (extendedleverage + vesuLeverage)
+     * VesuAmount = amountToInvest - ExtendedAmount
+     * @dev note: below cal includes existing exposures too
+     */
+
+    const extendedLeverage = calculateExtendedLevergae();
+    const vesuLeverage = calculateVesuLeverage();
     const vesuBTCExposureUSD = collateralUnits.multipliedBy(collateralPrice);
-    const numerator1 = vesu_leverage * amount + vesuBTCExposureUSD.toNumber();
-    const numerator2 = extendedExposureUSD.toNumber();
-    const denominator = vesu_leverage + extended_leverage;
+    const numerator1 = vesuLeverage * amountToInvest + vesuBTCExposureUSD.toNumber();
+    const numerator2 = extendedExposureUsd.toNumber();
+    const denominator = vesuLeverage + extendedLeverage;
     const ExtendedAmount = new Web3Number(
       ((numerator1 - numerator2) / denominator).toFixed(2),
-      USDC_TOKEN_DECIMALS
+      USDC_TOKEN_DECIMALS,
     );
 
     const VesuAmount = new Web3Number(
-      amount.toFixed(2),
-      USDC_TOKEN_DECIMALS
+      amountToInvest.toFixed(2),
+      USDC_TOKEN_DECIMALS,
     ).minus(ExtendedAmount);
 
     return {
-      vesu_amount: VesuAmount,
-      extended_amount: ExtendedAmount,
-      extended_leverage,
-      vesu_leverage,
+      vesuAmount: VesuAmount,
+      extendedAmount: ExtendedAmount,
+      extendedLeverage,
+      vesuLeverage,
     };
   } catch (err) {
     return {
-      vesu_amount: new Web3Number(0, 0),
-      extended_amount: new Web3Number(0, 0),
-      extended_leverage: 0,
-      vesu_leverage: 0,
+      vesuAmount: new Web3Number(0, 0),
+      extendedAmount: new Web3Number(0, 0),
+      extendedLeverage: 0,
+      vesuLeverage: 0,
     };
   }
 };
@@ -113,7 +111,7 @@ export const calculateAmountDistributionForWithdrawal = async (
   amountInUsdc: Web3Number,
   collateralPrice: number,
   collateralUnits: Web3Number,
-  extendedPosition: Position[] | null
+  extendedPosition: Position[] | null,
 ): Promise<{
   vesu_amount: Web3Number;
   extended_amount: Web3Number;
@@ -128,9 +126,9 @@ export const calculateAmountDistributionForWithdrawal = async (
       return null;
     }
     const extendedExposureUSD =
-    extendedPosition.length > 0
-    ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS)
-    : new Web3Number(0, USDC_TOKEN_DECIMALS);
+      extendedPosition.length > 0
+        ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS)
+        : new Web3Number(0, USDC_TOKEN_DECIMALS);
     const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
     if (vesuExposureUSD.lessThan(0)) {
       return {
@@ -148,24 +146,20 @@ export const calculateAmountDistributionForWithdrawal = async (
         vesu_leverage,
       };
     }
-    console.log("the vesu exposure usd is", vesuExposureUSD.toNumber());
-    console.log("the extended exposure usd is", extendedExposureUSD.toNumber());
-    console.log("the amount in usdc is", amountInUsdc.toNumber());
-    console.log("the extended leverage is", extended_leverage);
-    console.log("the vesu leverage is", vesu_leverage);
+    logger.debug(`calculateAmountDistributionForWithdrawal vesuExposureUsd=${vesuExposureUSD.toNumber()}`);
+    logger.debug(`calculateAmountDistributionForWithdrawal extendedExposureUsd=${extendedExposureUSD.toNumber()}`);
+    logger.debug(`calculateAmountDistributionForWithdrawal amountInUsdc=${amountInUsdc.toNumber()}`);
+    logger.debug(`calculateAmountDistributionForWithdrawal extendedLeverage=${extended_leverage}`);
+    logger.debug(`calculateAmountDistributionForWithdrawal vesuLeverage=${vesu_leverage}`);
     const numerator1 = amountInUsdc.multipliedBy(extended_leverage);
     const numerator2 = vesuExposureUSD;
-    const numerator3 = extendedExposureUSD
-      .multipliedBy(-1);
+    const numerator3 = extendedExposureUSD.multipliedBy(-1);
     const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
     const denominator = extended_leverage + vesu_leverage;
     const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
-    console.log("the vesu amount in usdc is", vesuAmountInUSDC.toNumber());
+    logger.debug(`calculateAmountDistributionForWithdrawal vesuAmountInUsdc=${vesuAmountInUSDC.toNumber()}`);
     const extendedAmountInUSDC = amountInUsdc.minus(vesuAmountInUSDC);
-    console.log(
-      "the extended amount in usdc is",
-      extendedAmountInUSDC.toNumber()
-    );
+    logger.debug(`calculateAmountDistributionForWithdrawal extendedAmountInUsdc=${extendedAmountInUSDC.toNumber()}`);
     //console.log("the vesu amount in usdc is", vesuAmountInUSDC.toNumber());
     //console.log("the extended amount in usdc is", extendedAmountInUSDC.toNumber());\
     await new Promise((resolve) => setTimeout(resolve, 10000));
@@ -176,7 +170,9 @@ export const calculateAmountDistributionForWithdrawal = async (
       vesu_leverage,
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`,
+    );
     return null;
   }
 };
@@ -186,10 +182,10 @@ export const calculateAmountDistributionForWithdrawal = async (
  * @returns {number} The calculated leverage value
  */
 export const calculateVesuLeverage = () => {
-  const max_ltv_ratio = (1 - MAX_PRICE_DROP_PERCENTAGE) * MAX_LIQUIDATION_RATIO; //0.75
-  const our_ltv_ratio = Math.floor(max_ltv_ratio * 100) - 5; //buffer of 5% to prevent liquidation
-  const leverage = 1 / (1 - our_ltv_ratio / 100);
-  return Math.ceil(leverage * 10) / 10;
+  const targetLtv = VesuConfig.targetLtv;
+  const debtBorrowed = targetLtv / (1 - targetLtv);
+  const leverage = (1 + debtBorrowed);
+  return leverage;
 };
 
 /**
@@ -216,32 +212,44 @@ export const calculateExtendedLevergae = () => {
  * @returns {object} Object containing deltadebtAmountUnits and isIncrease flag
  */
 // In case BTC_PRICE DROPS the added amount will be zero, and use this formula to calculated the debt that needs to be paid to maintain the ltv
+
 export const calculateDebtAmount = (
   collateralAmount: Web3Number,
   debtAmount: Web3Number,
   debtPrice: number,
-  maxLtv: number = MAX_LIQUIDATION_RATIO,
+  maxLtv: number = VesuConfig.maxLtv,
   addedAmount: Web3Number, // this is in btc
   collateralPrice: number,
-  isDeposit: boolean
+  isDeposit: boolean,
+  targetLtv: number = VesuConfig.targetLtv,
 ) => {
   try {
     // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
+    logger.debug(`calculateDebtAmount maxLtv=${maxLtv}, collateralAmount=${collateralAmount.toNumber()}`);
+    logger.debug(`calculateDebtAmount targetLtv=${targetLtv}, debtAmount=${debtAmount.toNumber()}`);
+
+    const targetHf = VesuConfig.maxLtv / targetLtv;
+    logger.debug(`calculateDebtAmount targetHf=${targetHf}`);
     const addedCollateral = addedAmount.multipliedBy(isDeposit ? 1 : -1);
-    const numerator1 = (collateralAmount
-      .plus(addedCollateral))
+    logger.debug(`calculateDebtAmount addedCollateral=${addedCollateral.toNumber()}, collateralPrice=${collateralPrice}`);
+    const numerator1 = collateralAmount
+      .plus(addedCollateral)
       .multipliedBy(collateralPrice)
       .multipliedBy(maxLtv);
+    logger.debug(`calculateDebtAmount numerator1=${numerator1.toNumber()}`);
     const numerator2 = debtAmount
       .multipliedBy(debtPrice)
-      .multipliedBy(TARGET_HF);
-    const denominator = TARGET_HF - maxLtv;
+      .multipliedBy(targetHf);
+    logger.debug(`calculateDebtAmount numerator2=${numerator2.toNumber()}`);
+    const denominator = targetHf - maxLtv;
+    logger.debug(`calculateDebtAmount denominator=${denominator}`);
     const x_debt_usd = numerator1.minus(numerator2).dividedBy(denominator);
-    let deltadebtAmountUnits = new Web3Number(
+    logger.debug(`calculateDebtAmount xDebtUsd=${x_debt_usd.toNumber()}`);
+    const deltadebtAmountUnits = new Web3Number(
       x_debt_usd.dividedBy(debtPrice).toFixed(2),
-      2
+      2,
     );
-    let isIncrease = x_debt_usd.greaterThan(0);
+    const isIncrease = x_debt_usd.greaterThan(0);
     return { deltadebtAmountUnits, isIncrease };
   } catch (err) {
     return { deltadebtAmountUnits: null, isIncrease: null };
@@ -266,7 +274,7 @@ export const calculateDebtReductionAmountForWithdrawal = (
   withdrawalAmount: Web3Number,
   collateralPrice: number,
   debtPrice: number,
-  usdcDecimals: number
+  usdcDecimals: number,
 ) => {
   try {
     const vesuLeverage = calculateVesuLeverage();
@@ -293,44 +301,99 @@ export const calculateDebtReductionAmountForWithdrawal = (
   }
 };
 
+
+// ! required?
 /**
  * calculate the amount to deposit on extended when incurring losses
  * @param client - The client
  * @returns The amount to deposit on extended when incurring losses
  */
 export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
-  client: ExtendedWrapper
+  client: ExtendedWrapper,
 ) => {
   try {
     const extendedHoldings = await client.getHoldings();
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`,
+      );
       return null;
     }
-    const positionValueInUSD = latestPosition.value;
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS,
+    );
     const equity = extendedHoldings.data.equity;
-    const deposit =
-      Number(positionValueInUSD) / extended_leverage - Number(equity);
-    return new Web3Number(Math.floor(deposit / 0.2) * 0.2, USDC_TOKEN_DECIMALS);
+    const deposit = positionValueInUSD
+      .dividedBy(extended_leverage)
+      .minus(equity)
+      .toFixed(2);
+    return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`,
+    );
     return null;
   }
 };
 
+/**
+ * calculate the amount of collateral to deposit to maintain the ltv
+ * The formula is:
+ * ((debt * debtPrice * targetHF) - (collateral * collateralPrice * ltv)) / ltv
+ * @param collateralAmount in collateral units
+ * @param debtAmount in debt units
+ * @param debtPrice in usd
+ * @param maxLtv
+ * @param collateralPrice in usd
+ * @param targetHF
+ * @returns deltaCollateralAmountUnits in collateral units
+ *          null if there is an error
+ */
+export const calculateWBTCAmountToMaintainLTV = (
+  collateralAmount: Web3Number,
+  debtAmount: Web3Number,
+  debtPrice: number,
+  maxLtv: number = MAX_LIQUIDATION_RATIO,
+  collateralPrice: number,
+) => {
+  try {
+    const targetHf = VesuConfig.maxLtv / VesuConfig.targetLtv;
+    const numerator1 = collateralAmount
+      .multipliedBy(collateralPrice)
+      .multipliedBy(maxLtv);
+    const numerator2 = debtAmount
+      .multipliedBy(debtPrice)
+      .multipliedBy(targetHf);
+    const denominator = maxLtv;
+    const collateralAmountToMaintainLTV = numerator2
+      .minus(numerator1)
+      .dividedBy(denominator);
+    let deltaCollateralAmountUnits = new Web3Number(
+      collateralAmountToMaintainLTV
+        .dividedBy(collateralPrice)
+        .toFixed(WBTC_TOKEN_DECIMALS),
+      WBTC_TOKEN_DECIMALS,
+    );
+    return { deltaCollateralAmountUnits };
+  } catch (err) {
+    return { deltaCollateralAmountUnits: null };
+  }
+};
+
+// ! required?
 export const calculateExposureDelta = (
   exposure_extended: number,
-  exposure_vesu: number
+  exposure_vesu: number,
 ) => {
   const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
   return exposure_delta.absoluteValue().toNumber();
 };
 
-/// In case BTC PRICE DROPS
-// 1. calculate the ltv on vesu
-// 2. Find the debt that needs to be paid to maintain the ltv
 
+// ! required?
 /**
  * calculate the delta percentage between the current btc price and the last btc price
  * @param {number} btcPrice - The current btc price
@@ -339,34 +402,127 @@ export const calculateExposureDelta = (
  */
 export const calculateBTCPriceDelta = (
   btcPrice: number,
-  lastBtcPrice: number
+  lastBtcPrice: number,
 ) => {
   return ((btcPrice - lastBtcPrice) / lastBtcPrice) * 100;
 };
 
 export const calculateVesUPositionSizeGivenExtended = (
-  extendedPositonValue: number,
+  extendedPositonSize: number,
   extendedHoldingAmount: Web3Number,
   collateralAmount: Web3Number,
-  collateralPrice: number
+  extendedBtcPrice: number,
 ) => {
   const extendedLeverage = calculateExtendedLevergae();
   const vesuLeverage = calculateVesuLeverage();
-  const extendedAmount = extendedHoldingAmount;
-  const extendedAmountInBTC = extendedAmount
-    .dividedBy(collateralPrice)
-  const numerator1 = extendedAmount.multipliedBy(extendedLeverage)
-    .plus(extendedPositonValue)
+  logger.debug(`calculateVesUPositionSizeGivenExtended extendedLeverage=${extendedLeverage}`);
+  logger.debug(`calculateVesUPositionSizeGivenExtended vesuLeverage=${vesuLeverage}`);
+  const extendedAmountInBTC = new Web3Number(extendedHoldingAmount.dividedBy(extendedBtcPrice).toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+  logger.debug(`calculateVesUPositionSizeGivenExtended extendedAmountInBTC=${extendedAmountInBTC.toNumber()}`);
+  const numerator1 = extendedAmountInBTC
+    .multipliedBy(extendedLeverage)
+    .plus(extendedPositonSize);
+  logger.debug(`calculateVesUPositionSizeGivenExtended numerator1=${numerator1.toNumber()}`);
   const numerator2 = collateralAmount
-    .multipliedBy(collateralPrice)
     .multipliedBy(-1);
-  const vesuAmountInUsd = numerator1.plus(numerator2).dividedBy(vesuLeverage);
-  const vesuAmountInBTC = vesuAmountInUsd
-    .dividedBy(collateralPrice)
-    .toFixed(WBTC_TOKEN_DECIMALS);
+  logger.debug(`calculateVesUPositionSizeGivenExtended numerator2=${numerator2.toNumber()}`);
+  const vesuAmountInBTC = new Web3Number(numerator1.plus(numerator2).dividedBy(vesuLeverage).toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+  logger.debug(`calculateVesUPositionSizeGivenExtended vesuAmountInBTC=${vesuAmountInBTC.toNumber()}`);
   return {
-    vesuAmountInUsd: vesuAmountInUsd.toFixed(2),
-    vesuAmountInBTC: new Web3Number(vesuAmountInBTC, WBTC_TOKEN_DECIMALS),
+    vesuAmountInBTC: vesuAmountInBTC,
     extendedAmountInBTC: extendedAmountInBTC,
   };
 };
+
+/**
+ * calculate the debt amount to be repaid to maintain the ltv
+ * @param maxLtv - The maximum ltv
+ * @param existingVesuCollateral - The existing vesu collateral
+ * @param existingVesuDebt - The existing vesu debt
+ * @param collateralPrice - The collateral price
+ * @param debtPrice - The debt price
+ * @param targetHf - The target hf
+ * @@dev returns negative to represent debt to be repaid
+ * @returns The debt amount to be repaid
+ */
+export const calculateDeltaDebtAmount = (
+  existingVesuCollateral: Web3Number,
+  existingVesuDebt: Web3Number,
+  debtPrice: number,
+  collateralPrice: number,
+) => {
+  const currentHf = HealthFactorMath.getHealthFactor(
+    existingVesuCollateral,
+    collateralPrice,
+    VesuConfig.maxLtv,
+    existingVesuDebt,
+    debtPrice
+  );
+  const targetHf = VesuConfig.maxLtv / VesuConfig.targetLtv;
+  logger.debug(`calculateDeltaDebtAmount currentHf=${currentHf} targetHf=${targetHf}`);
+
+  const term1 = existingVesuCollateral
+    .multipliedBy(collateralPrice)
+    .multipliedBy(VesuConfig.maxLtv);
+
+  const term2 = existingVesuDebt
+    .multipliedBy(debtPrice)
+    .multipliedBy(targetHf)
+    .multipliedBy(-1);
+  const debtAmountToBeRepaid = term1.plus(term2).dividedBy(targetHf);
+  return {
+    deltaDebt: new Web3Number(
+      debtAmountToBeRepaid.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
+    ),
+    shouldRebalance: currentHf < (targetHf - 0.05),
+  }
+};
+
+export const calculatePositionToCloseToWithdrawAmount = async (
+  extendedBalance: Balance,
+  extendedPositions: Position,
+  amountToWithdraw: Web3Number,
+) => {
+  try {
+    const extendedLeverage = calculateExtendedLevergae();
+    const extendedPosition = extendedPositions.value;
+    const marginRequired = new Web3Number(
+      extendedBalance.initialMargin,
+      USDC_TOKEN_DECIMALS,
+    );
+    const unrealisedPnl = new Web3Number(
+      extendedBalance.unrealisedPnl,
+      USDC_TOKEN_DECIMALS,
+    );
+    const availableForWithdrawal = new Web3Number(
+      extendedBalance.availableForWithdrawal,
+      USDC_TOKEN_DECIMALS,
+    );
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+    /**
+     * New Formula
+     */
+    const walletBalance = new Web3Number(
+      extendedBalance.balance,
+      USDC_TOKEN_DECIMALS,
+    );
+    const term1 = marginRequired
+      .minus(walletBalance)
+      .minus(availableForWithdrawal)
+      .plus(amountToWithdraw)
+      .multipliedBy(extendedLeverage);
+    const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+    return new Web3Number(
+      Math.ceil(
+        term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber(),
+      ),
+      USDC_TOKEN_DECIMALS,
+    );
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`,
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};