@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

package/src/strategies/vesu-extended-strategy/services/operationService.ts

@@ -2,9 +2,19 @@ import { Web3Number } from "@/dataTypes";
 import { ExtendedAdapter } from "@/strategies/universal-adapters/extended-adapter";
 import { VesuMultiplyAdapter } from "../../universal-adapters/vesu-multiply-adapter";
 import { CycleType, TransactionResult } from "../types/transaction-metadata";
-
+import { UsdcToUsdceAdapter } from "@/strategies/universal-adapters/usdc<>usdce-adapter";
+import { AssetMovementPlan } from "../vesu-extended-strategy";
 export abstract class Operations {
 
+  abstract computeAssetMovements(
+    extendedAmount: Web3Number,
+    vesuAmount: Web3Number
+  ): Promise<AssetMovementPlan | null>;
+
+  abstract executeAssetMovements(
+    plan: AssetMovementPlan
+  ): Promise<TransactionResult[]>;
+
   abstract shouldMoveAssets(
     extendedAmount: Web3Number,
     vesuAmount: Web3Number
@@ -28,6 +38,7 @@ export abstract class Operations {
     params: { from: string; to: string; amount: Web3Number, cycleType: CycleType },
     extendedAdapter: ExtendedAdapter,
     vesuAdapter: VesuMultiplyAdapter,
+    usdcToUsdceAdapter: UsdcToUsdceAdapter,
   ): Promise<TransactionResult>;
   /**
    * Handle deposit operation.

package/src/strategies/vesu-extended-strategy/types/transaction-metadata.ts

@@ -32,5 +32,57 @@ export interface TransactionResult<T = any> {
   transactionMetadata: TransactionMetadata;
 }
 
+// ─── Execution Lifecycle Events ─────────────────────────────────────────────
 
+/**
+ * Key lifecycle event types emitted during execution.
+ * Used by callers (e.g. risk engine) to hook into the execution pipeline
+ * and persist state to DB, send alerts, etc.
+ */
+export enum ExecutionEventType {
+  /** Execution started — tx sent on-chain or order placed on exchange */
+  INITIATED = 'INITIATED',
+  /** Execution completed successfully — tx confirmed / order filled */
+  SUCCESS = 'SUCCESS',
+  /** Execution failed — tx reverted / order rejected / timeout */
+  FAILURE = 'FAILURE',
+}
+
+/**
+ * Metadata payload accompanying each execution lifecycle event.
+ * Contains relevant identifiers, prices, and contextual information.
+ */
+export interface ExecutionEventMetadata {
+  /** Route type string (e.g. RouteType value) */
+  routeType?: string;
+  /** Human-readable route summary */
+  routeSummary?: string;
+  /** On-chain transaction hash (when available) */
+  txHash?: string;
+  /** Exchange order ID (for off-chain orders) */
+  orderId?: string;
+  /** Amount involved in the operation */
+  amount?: string;
+  /** Protocol name */
+  protocol?: string;
+  /** Actual execution price (for exchange orders) */
+  executionPrice?: number;
+  /** Limit price that was set */
+  limitPrice?: number;
+  /** Error message on failure */
+  error?: string;
+  /** On-chain calls that were built */
+  calls?: Call[];
+  /** Extensible: any extra metadata */
+  [key: string]: any;
+}
+
+/**
+ * Callback invoked on key execution lifecycle events.
+ * Callers can use this to save to DB, send notifications, log, etc.
+ */
+export type ExecutionCallback = (
+  eventType: ExecutionEventType,
+  metadata: ExecutionEventMetadata,
+) => void | Promise<void>;
 

package/src/strategies/vesu-extended-strategy/utils/config.runtime.ts

@@ -62,6 +62,7 @@ export const VesuConfig = {
   avnu: {
     api: AVNU_API,
   },
+  targetLtv : 0.61,
   minDebtForVesuRebalacing:MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING
 } as const;
 

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

@@ -18,6 +18,8 @@ export const STRK_API_RPC = process.env.STRK_API_RPC ?? "https://mainnet.starkne
 export const MAX_RETRIES = Number(process.env.MAX_RETRIES ?? 3);
 export const MAX_DELAY = Number(process.env.MAX_DELAY ?? 100);
 export const EXTEND_MARKET_NAME = "BTC-USD";
+
+// factor of balance to keep as buffer (0.05 = 5%)
 export const LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 0.05);
 export const LIMIT_BALANCE_VALUE=20;
 export const REBALANCER_INTERVAL = Number(process.env.REBALANCER_INTERVAL ?? 180000); //3 mins

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

@@ -9,6 +9,7 @@ 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";
@@ -16,6 +17,7 @@ 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,
@@ -29,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);
@@ -37,67 +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 extendedExposureUSD =
-      extendedPosition.length > 0
-        ? new Web3Number(extendedPosition[0].value, WBTC_TOKEN_DECIMALS)
-        : new Web3Number(0, WBTC_TOKEN_DECIMALS);
+    /**
+     * 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;
@@ -148,23 +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 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 +171,7 @@ export const calculateAmountDistributionForWithdrawal = async (
     };
   } catch (err) {
     logger.error(
-      `error calculating amount distribution for withdrawal: ${err}`
+      `error calculating amount distribution for withdrawal: ${err}`,
     );
     return null;
   }
@@ -187,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;
 };
 
 /**
@@ -217,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);
+    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 };
@@ -267,7 +274,7 @@ export const calculateDebtReductionAmountForWithdrawal = (
   withdrawalAmount: Web3Number,
   collateralPrice: number,
   debtPrice: number,
-  usdcDecimals: number
+  usdcDecimals: number,
 ) => {
   try {
     const vesuLeverage = calculateVesuLeverage();
@@ -294,13 +301,15 @@ 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();
@@ -308,13 +317,13 @@ export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
       logger.error(
-        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`,
       );
       return null;
     }
     const positionValueInUSD = new Web3Number(
       latestPosition.value,
-      USDC_TOKEN_DECIMALS
+      USDC_TOKEN_DECIMALS,
     );
     const equity = extendedHoldings.data.equity;
     const deposit = positionValueInUSD
@@ -324,7 +333,7 @@ export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
     logger.error(
-      `error calculating amount deposit on extended when incurring losses: ${err}`
+      `error calculating amount deposit on extended when incurring losses: ${err}`,
     );
     return null;
   }
@@ -349,15 +358,15 @@ export const calculateWBTCAmountToMaintainLTV = (
   debtPrice: number,
   maxLtv: number = MAX_LIQUIDATION_RATIO,
   collateralPrice: number,
-  targetHF: number = TARGET_HF
 ) => {
   try {
+    const targetHf = VesuConfig.maxLtv / VesuConfig.targetLtv;
     const numerator1 = collateralAmount
       .multipliedBy(collateralPrice)
       .multipliedBy(maxLtv);
     const numerator2 = debtAmount
       .multipliedBy(debtPrice)
-      .multipliedBy(targetHF);
+      .multipliedBy(targetHf);
     const denominator = maxLtv;
     const collateralAmountToMaintainLTV = numerator2
       .minus(numerator1)
@@ -366,7 +375,7 @@ export const calculateWBTCAmountToMaintainLTV = (
       collateralAmountToMaintainLTV
         .dividedBy(collateralPrice)
         .toFixed(WBTC_TOKEN_DECIMALS),
-      WBTC_TOKEN_DECIMALS
+      WBTC_TOKEN_DECIMALS,
     );
     return { deltaCollateralAmountUnits };
   } catch (err) {
@@ -374,18 +383,17 @@ export const calculateWBTCAmountToMaintainLTV = (
   }
 };
 
+// ! 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
@@ -394,36 +402,34 @@ 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
+  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(extendedPositonValue);
+    .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,
   };
 };
@@ -436,58 +442,86 @@ export const calculateVesUPositionSizeGivenExtended = (
  * @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 = (
-  maxLtv: number = MAX_LTV_BTC_USDC,
   existingVesuCollateral: Web3Number,
   existingVesuDebt: Web3Number,
-  collateralPrice: number,
   debtPrice: number,
-  targetHf: number = TARGET_HF
+  collateralPrice: number,
 ) => {
-  try {
-    const term1 = existingVesuCollateral
-      .multipliedBy(collateralPrice)
-      .multipliedBy(maxLtv);
+  const currentHf = HealthFactorMath.getHealthFactor(
+    existingVesuCollateral,
+    collateralPrice,
+    VesuConfig.maxLtv,
+    existingVesuDebt,
+    debtPrice
+  );
+  const targetHf = VesuConfig.maxLtv / VesuConfig.targetLtv;
+  logger.debug(`calculateDeltaDebtAmount currentHf=${currentHf} targetHf=${targetHf}`);
 
-    logger.info(`term1: ${term1.toNumber()}`);
-    const term2 = existingVesuDebt
-      .multipliedBy(debtPrice)
-      .multipliedBy(targetHf)
-      .multipliedBy(-1);
-    logger.info(`term2: ${term2.toNumber()}`);
-    const debtAmountToBeRepaid = term1.plus(term2).dividedBy(targetHf);
-    logger.info(`debtAmountToBeRepaid: ${debtAmountToBeRepaid.toNumber()}`);
-    return new Web3Number(debtAmountToBeRepaid.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
-  } catch (err) {
-    logger.error(`error calculating delta position: ${err}`);
-    return null;
+  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
+  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)
+    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 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);
+    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}`
+      `error calculating position to close to withdraw amount: ${err}`,
     );
     return new Web3Number(0, USDC_TOKEN_DECIMALS);
   }