@strkfarm/sdk 2.0.0-dev.35 → 2.0.0-dev.36

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

@@ -1,528 +0,0 @@
-import {
-  MAINTENANCE_MARGIN,
-  MAX_LTV_BTC_USDC,
-  MAX_PRICE_DROP_PERCENTAGE,
-  TARGET_HF,
-  WBTC_TOKEN_ADDRESS,
-  USDC_TOKEN_ADDRESS,
-  WBTC_TOKEN_DECIMALS,
-  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,
-// } from "../services/vesuService";
-/**
- * Function to return formatted amount to BigInt
- * Converts a decimal amount to the proper format for blockchain transactions
- * @param {number} amount - The decimal amount to convert
- * @param {number} fromTokenDecimals - The decimal precision of the token
- * @returns {string} The formatted amount as a hexadecimal string
- */
-export const returnFormattedAmount = (
-  amount: number,
-  toTokenDecimals: number,
-) => {
-  const formattedAmount =
-    "0x" + BigInt(Math.floor(amount * 10 ** toTokenDecimals)).toString(16);
-  return formattedAmount;
-};
-
-/**
- * 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 = (
-  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 {
-    /**
-     * 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 = vesuLeverage * amountToInvest + vesuBTCExposureUSD.toNumber();
-    const numerator2 = extendedExposureUsd.toNumber();
-    const denominator = vesuLeverage + extendedLeverage;
-    const ExtendedAmount = new Web3Number(
-      ((numerator1 - numerator2) / denominator).toFixed(2),
-      USDC_TOKEN_DECIMALS,
-    );
-
-    const VesuAmount = new Web3Number(
-      amountToInvest.toFixed(2),
-      USDC_TOKEN_DECIMALS,
-    ).minus(ExtendedAmount);
-
-    return {
-      vesuAmount: VesuAmount,
-      extendedAmount: ExtendedAmount,
-      extendedLeverage,
-      vesuLeverage,
-    };
-  } catch (err) {
-    return {
-      vesuAmount: new Web3Number(0, 0),
-      extendedAmount: new Web3Number(0, 0),
-      extendedLeverage: 0,
-      vesuLeverage: 0,
-    };
-  }
-};
-
-/**
- * calculate the amount distribution for withdrawal
- * @param amount - The amount to withdraw
- * @param client - The client
- * @param marketName - The market name
- * @returns {object} Object containing avnu_amount and extended_amount
- */
-export const calculateAmountDistributionForWithdrawal = async (
-  amountInUsdc: Web3Number,
-  collateralPrice: number,
-  collateralUnits: Web3Number,
-  extendedPosition: Position[] | null,
-): Promise<{
-  vesu_amount: Web3Number;
-  extended_amount: Web3Number;
-  extended_leverage: number;
-  vesu_leverage: number;
-} | null> => {
-  try {
-    const extended_leverage = calculateExtendedLevergae();
-    const vesu_leverage = calculateVesuLeverage();
-    if (extendedPosition === null) {
-      logger.error("error getting extended positions");
-      return null;
-    }
-    const extendedExposureUSD =
-      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 {
-        vesu_amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
-        extended_amount: amountInUsdc,
-        extended_leverage,
-        vesu_leverage,
-      };
-    }
-    if (extendedExposureUSD.lessThan(0)) {
-      return {
-        vesu_amount: amountInUsdc,
-        extended_amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
-        extended_leverage,
-        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 finalNumerator = numerator1.plus(numerator2).plus(numerator3);
-    const denominator = extended_leverage + vesu_leverage;
-    const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
-    logger.debug(`calculateAmountDistributionForWithdrawal vesuAmountInUsdc=${vesuAmountInUSDC.toNumber()}`);
-    const extendedAmountInUSDC = amountInUsdc.minus(vesuAmountInUSDC);
-    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));
-    return {
-      vesu_amount: vesuAmountInUSDC,
-      extended_amount: extendedAmountInUSDC,
-      extended_leverage,
-      vesu_leverage,
-    };
-  } catch (err) {
-    logger.error(
-      `error calculating amount distribution for withdrawal: ${err}`,
-    );
-    return null;
-  }
-};
-/**
- * calculate the leverage required for Avnu
- * calculates the optimal leverage for Avnu based on LTV ratios and price drop protection
- * @returns {number} The calculated leverage value
- */
-export const calculateVesuLeverage = () => {
-  const targetLtv = VesuConfig.targetLtv;
-  const debtBorrowed = targetLtv / (1 - targetLtv);
-  const leverage = (1 + debtBorrowed);
-  return leverage;
-};
-
-/**
- * calculate leverage for extended
- * calculates the maximum safe leverage for Extended based on maintenance margin and price drop protection
- * @returns {number} The calculated leverage value
- */
-export const calculateExtendedLevergae = () => {
-  const extended_leverage_max =
-    1 / (MAINTENANCE_MARGIN + MAX_PRICE_DROP_PERCENTAGE);
-  return Math.floor(extended_leverage_max);
-};
-
-/**
- * calculates the debt amount for leverage operations
- * Determines how much debt to add or remove based on collateral changes and target health factor
- * @param {Web3Number} collateralAmount - Current collateral amount
- * @param {Web3Number} debtAmount - Current debt amount
- * @param {number} debtPrice - Current price of the debt token
- * @param {number} maxLtv - Maximum loan-to-value ratio (default: MAX_LTV_BTC_USDC)
- * @param {number} addedAmount - Amount being added to collateral
- * @param {number} collateralPrice - Current price of the collateral token
- * @param {boolean} isDeposit - Whether this is a deposit (true) or withdrawal (false)
- * @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 = VesuConfig.maxLtv,
-  addedAmount: Web3Number, // this is in btc
-  collateralPrice: number,
-  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);
-    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(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);
-    logger.debug(`calculateDebtAmount xDebtUsd=${x_debt_usd.toNumber()}`);
-    const deltadebtAmountUnits = new Web3Number(
-      x_debt_usd.dividedBy(debtPrice).toFixed(2),
-      2,
-    );
-    const isIncrease = x_debt_usd.greaterThan(0);
-    return { deltadebtAmountUnits, isIncrease };
-  } catch (err) {
-    return { deltadebtAmountUnits: null, isIncrease: null };
-  }
-};
-
-/**
- * calculate the debt amount to be repaid for withdrawal
- * @param debtAmount in debt units
- * @param collateralAmount in collateral units
- * @param maxLtv in percentage
- * @param withdrawalAmount in collateral units
- * @param collateralPrice in usd
- * @param debtPrice in usd
- * @returns deltadebtAmountUnits in debt units
- *          isIncrease: true if the debt amount is increasing, false if it is decreasing
- */
-export const calculateDebtReductionAmountForWithdrawal = (
-  debtAmount: Web3Number,
-  collateralAmount: Web3Number,
-  maxLtv: number = MAX_LTV_BTC_USDC,
-  withdrawalAmount: Web3Number,
-  collateralPrice: number,
-  debtPrice: number,
-  usdcDecimals: number,
-) => {
-  try {
-    const vesuLeverage = calculateVesuLeverage();
-    const numerator1 = collateralAmount
-      .multipliedBy(collateralPrice)
-      .multipliedBy(maxLtv)
-      .multipliedBy(-1);
-    withdrawalAmount = withdrawalAmount.multipliedBy(vesuLeverage);
-    const numerator2 = debtAmount
-      .multipliedBy(debtPrice)
-      .multipliedBy(TARGET_HF);
-    const numerator3 = withdrawalAmount
-      .multipliedBy(collateralPrice)
-      .multipliedBy(maxLtv);
-    const numeratorTotal = numerator1.plus(numerator2).plus(numerator3);
-    const denominator = debtPrice * TARGET_HF;
-    const x_debt_usdc = numeratorTotal.dividedBy(denominator);
-    let deltadebtAmountUnits = x_debt_usdc
-      .multipliedBy(-1)
-      .toFixed(usdcDecimals); // means we are paying debt
-    return { deltadebtAmountUnits };
-  } catch (err) {
-    return { deltadebtAmountUnits: null };
-  }
-};
-
-
-// ! 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,
-) => {
-  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}`,
-      );
-      return null;
-    }
-    const positionValueInUSD = new Web3Number(
-      latestPosition.value,
-      USDC_TOKEN_DECIMALS,
-    );
-    const equity = extendedHoldings.data.equity;
-    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,
-) => {
-  const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
-  return exposure_delta.absoluteValue().toNumber();
-};
-
-
-// ! required?
-/**
- * calculate the delta percentage between the current btc price and the last btc price
- * @param {number} btcPrice - The current btc price
- * @param {number} lastBtcPrice - The last btc price
- * @returns {number} The delta percentage
- */
-export const calculateBTCPriceDelta = (
-  btcPrice: number,
-  lastBtcPrice: number,
-) => {
-  return ((btcPrice - lastBtcPrice) / lastBtcPrice) * 100;
-};
-
-export const calculateVesUPositionSizeGivenExtended = (
-  extendedPositonSize: number,
-  extendedHoldingAmount: Web3Number,
-  collateralAmount: Web3Number,
-  extendedBtcPrice: number,
-) => {
-  const extendedLeverage = calculateExtendedLevergae();
-  const vesuLeverage = calculateVesuLeverage();
-  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(-1);
-  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 {
-    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);
-  }
-};