@strkfarm/sdk 2.0.0-dev.21 → 2.0.0-dev.23

package/src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx

@@ -8,12 +8,21 @@ import {
   UNIVERSAL_MANAGE_IDS,
   UniversalStrategySettings,
 } from "../universal-strategy";
-import { calculateExtendedLevergae } from "./utils/helper";
+import { calculateDebtAmount, calculateDeltaDebtAmount, calculateExtendedLevergae } from "./utils/helper";
 import { logger } from "@/utils";
 import { AUDIT_URL } from "../universal-lst-muliplier-strategy";
 import { getNoRiskTags } from "@/interfaces";
 import { _riskFactor } from "../universal-lst-muliplier-strategy";
-import { BUFFER_USDC_IN_WITHDRAWAL, LIMIT_BALANCE, LIMIT_BALANCE_VALUE, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WALLET_ADDRESS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
+import {
+  BUFFER_USDC_IN_WITHDRAWAL,
+  LIMIT_BALANCE,
+  LIMIT_BALANCE_VALUE,
+  MAX_LTV_BTC_USDC,
+  MINIMUM_EXTENDED_POSITION_SIZE,
+  USDC_TOKEN_DECIMALS,
+  WALLET_ADDRESS,
+  WBTC_TOKEN_DECIMALS,
+} from "./utils/constants";
 import { CycleType } from "./types/transaction-metadata";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
@@ -22,7 +31,10 @@ import { ERC20 } from "@/modules";
 import { Balance, OrderSide } from "@/modules/ExtendedWrapperSDk";
 import { Protocols } from "@/interfaces";
 import { MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP } from "./utils/constants";
-import { getInvestmentSteps, getFAQs } from "../universal-lst-muliplier-strategy";
+import {
+  getInvestmentSteps,
+  getFAQs,
+} from "../universal-lst-muliplier-strategy";
 import { getContractDetails } from "../universal-strategy";
 import { highlightTextWithLinks } from "@/interfaces";
 import { PositionInfo } from "../universal-adapters";
@@ -50,13 +62,15 @@ import {
   calculateAmountDistribution,
   calculateAmountDistributionForWithdrawal,
   calculateVesuLeverage,
-  calculateVesUPositionSizeGivenExtended
+  calculateVesUPositionSizeGivenExtended,
 } from "./utils/helper";
 import { SingleTokenInfo } from "../base-strategy";
 import { Call } from "starknet";
 import { PositionTypeAvnuExtended } from "../universal-strategy";
-import { TransactionMetadata, TransactionResult } from "./types/transaction-metadata";
-
+import {
+  TransactionMetadata,
+  TransactionResult,
+} from "./types/transaction-metadata";
 
 export interface VesuExtendedStrategySettings
   extends UniversalStrategySettings {
@@ -71,10 +85,11 @@ export interface VesuExtendedStrategySettings
 }
 
 export class VesuExtendedMultiplierStrategy<
-  S extends VesuExtendedStrategySettings
->
+    S extends VesuExtendedStrategySettings
+  >
   extends SVKStrategy<S>
-  implements Operations {
+  implements Operations
+{
   constructor(
     config: IConfig,
     pricer: PricerBase,
@@ -122,8 +137,7 @@ export class VesuExtendedMultiplierStrategy<
       usdceToken.decimals
     );
     const price = await this.pricer.getPrice(usdceToken.symbol);
-    const usdValue =
-      Number(balance.toFixed(usdceToken.decimals)) * price.price;
+    const usdValue = Number(balance.toFixed(usdceToken.decimals)) * price.price;
     return {
       tokenInfo: usdceToken,
       amount: balance,
@@ -131,7 +145,6 @@ export class VesuExtendedMultiplierStrategy<
     };
   }
 
-
   async getUnusedBalanceWBTC(): Promise<SingleTokenInfo> {
     const collateralToken = this.metadata.additionalInfo.borrowable_assets[0]!;
     const balance = await new ERC20(this.config).balanceOf(
@@ -182,9 +195,12 @@ export class VesuExtendedMultiplierStrategy<
     return extendedAdapter.adapter as ExtendedAdapter;
   }
 
-  async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<{
-    calls: Call[],
-    status: boolean,
+  async moveAssetsToVaultAllocator(
+    amount: Web3Number,
+    extendedAdapter: ExtendedAdapter
+  ): Promise<{
+    calls: Call[];
+    status: boolean;
   }> {
     try {
       const usdceToken = Global.getDefaultTokens().find(
@@ -195,12 +211,22 @@ export class VesuExtendedMultiplierStrategy<
         WALLET_ADDRESS,
         usdceToken.decimals
       );
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`);
+      logger.info(
+        `${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`
+      );
       const amountToBeTransferred = amount.minimum(walletBalance);
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`);
-  
+      logger.info(
+        `${
+          VesuExtendedMultiplierStrategy.name
+        }::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`
+      );
+
       if (amountToBeTransferred.lessThan(0)) {
-        logger.error(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`);
+        logger.error(
+          `${
+            VesuExtendedMultiplierStrategy.name
+          }::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`
+        );
         return {
           calls: [],
           status: false,
@@ -246,12 +272,19 @@ export class VesuExtendedMultiplierStrategy<
     collateralPrice: number;
     debtPrice: number;
     vesuLeverage: number;
+    debtAmountToBeRepaid: Web3Number;
   }> {
     try {
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
+      logger.info(
+        `${VesuExtendedMultiplierStrategy.name}::shouldInvest starting`
+      );
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+      logger.info(
+        `${
+          VesuExtendedMultiplierStrategy.name
+        }::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`
+      );
 
       if (!vesuAdapter) {
         logger.error(
@@ -265,6 +298,7 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
       if (!extendedAdapter) {
@@ -279,6 +313,7 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
       if (!extendedAdapter.client) {
@@ -293,10 +328,13 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
 
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
+      logger.info(
+        `${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`
+      );
       const balance = await this.getUnusedBalance();
 
       if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
@@ -311,14 +349,23 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
-      const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
+      logger.info(
+        `${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`
+      );
+      const usdcBalanceOnExtended =
+        await extendedAdapter.getExtendedDepositAmount();
 
       if (usdcBalanceOnExtended) {
-        const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
-        if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+        const availableForWithdrawal = parseFloat(
+          usdcBalanceOnExtended.availableForWithdrawal
+        );
+        if (
+          !Number.isFinite(availableForWithdrawal) ||
+          availableForWithdrawal < 0
+        ) {
           logger.error(
             `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
           );
@@ -330,13 +377,18 @@ export class VesuExtendedMultiplierStrategy<
             collateralPrice: 0,
             debtPrice: 0,
             vesuLeverage: 0,
+            debtAmountToBeRepaid: new Web3Number(0, 0),
           };
         }
       }
 
       /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
-      const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).multipliedBy(1 - LIMIT_BALANCE);
-
+      const amountToInvest = new Web3Number(
+        balance.usdValue,
+        USDC_TOKEN_DECIMALS
+      )
+        .plus(usdcBalanceOnExtended?.availableForTrade ?? 0)
+        .multipliedBy(1 - LIMIT_BALANCE);
 
       const amountToInvestNumber = amountToInvest.toNumber();
       if (!Number.isFinite(amountToInvestNumber)) {
@@ -351,10 +403,14 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
 
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+      logger.info(
+        `${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`
+      );
+      
       if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
           shouldInvest: false,
@@ -364,6 +420,7 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
 
@@ -378,18 +435,18 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
-      const { collateralTokenAmount } =
+      const { collateralTokenAmount, debtTokenAmount } =
         await vesuAdapter.vesuAdapter.getAssetPrices();
 
-      const {
-        collateralPrice,
-        debtPrice
-      } = await this.getAssetPrices();
+      const { collateralPrice, debtPrice } = await this.getAssetPrices();
 
-
-      if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+      if (
+        !Number.isFinite(collateralPrice.price) ||
+        collateralPrice.price <= 0
+      ) {
         logger.error(
           `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
         );
@@ -401,6 +458,7 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
       if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
@@ -415,12 +473,35 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
 
+      const debtAmountToBeRepaid = calculateDeltaDebtAmount(
+        MAX_LTV_BTC_USDC,
+        collateralTokenAmount,
+        debtTokenAmount,
+        collateralPrice.price,
+        debtPrice.price,
+        this.metadata.additionalInfo.targetHealthFactor
+      );
+      if (!debtAmountToBeRepaid) {
+        logger.error("error calculating debt amount to be repaid");
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
+        };
+      }
+      const amountToInvestAfterRepayingDebt = amountToInvest.minus(debtAmountToBeRepaid);
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
         await calculateAmountDistribution(
-          amountToInvest.toNumber(),
+          amountToInvestAfterRepayingDebt.toNumber(),
           extendedAdapter.client,
           extendedAdapter.config.extendedMarketName,
           collateralPrice.price,
@@ -445,9 +526,14 @@ export class VesuExtendedMultiplierStrategy<
           collateralPrice: 0,
           debtPrice: 0,
           vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
+      logger.info(
+        `${
+          VesuExtendedMultiplierStrategy.name
+        }::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`
+      );
       return {
         shouldInvest: true,
         vesuAmount: vesu_amount,
@@ -456,6 +542,7 @@ export class VesuExtendedMultiplierStrategy<
         vesuLeverage: vesu_leverage,
         collateralPrice: collateralPrice.price,
         debtPrice: debtPrice.price,
+        debtAmountToBeRepaid: debtAmountToBeRepaid,
       };
     } catch (err) {
       logger.error(`error deciding invest: ${err}`);
@@ -467,11 +554,15 @@ export class VesuExtendedMultiplierStrategy<
         collateralPrice: 0,
         debtPrice: 0,
         vesuLeverage: 0,
+        debtAmountToBeRepaid: new Web3Number(0, 0),
       };
     }
   }
 
-  async shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<TransactionResult[]> {
+  async shouldMoveAssets(
+    extendedAmount: Web3Number,
+    vesuAmount: Web3Number
+  ): Promise<TransactionResult[]> {
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -488,37 +579,58 @@ export class VesuExtendedMultiplierStrategy<
         return [];
       }
       const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
-      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
-        extendedHoldings.availableForWithdrawal
+      /**
+       * Trade is the correct metric, since we can close position for some vesu amount, otherwise underutilisation of funds will be a huge issue
+       */
+      const usdcAmountOnExtendedAvailableForTrade = parseFloat(
+        extendedHoldings.availableForTrade
       );
 
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForWithdrawal}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`);
+      logger.info(
+        `${
+          VesuExtendedMultiplierStrategy.name
+        }::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForTrade}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`
+      );
 
       let totalExtendedWithdrawal = new Web3Number(0, USDC_TOKEN_DECIMALS);
       let totalExtendedDeposit = new Web3Number(0, USDC_TOKEN_DECIMALS);
 
-      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmount.abs());
+      if (
+        extendedAmount.isNegative() &&
+        extendedAmount
+          .abs()
+          .greaterThan(extendedAdapter.minimumExtendedMovementAmount)
+      ) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
+          extendedAmount.abs()
+        );
       }
 
       // Calculate remaining Extended difference (target vs current)
       // If extendedAmount was negative, we've already accounted for that withdrawal
       // So we calculate based on what Extended will be after that withdrawal
       const extendedTargetAmount = extendedAmount.abs(); // Use absolute value as target
-      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForTrade;
 
       if (extendedAmount.isNegative()) {
-        projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+        projectedExtendedBalance =
+          projectedExtendedBalance - extendedAmount.abs().toNumber();
       }
 
-      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifference = extendedTargetAmount.minus(
+        projectedExtendedBalance
+      );
       const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
 
       // Track additional Extended movements
       if (extendedAmountDifference.lessThan(0)) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
+          extendedAmountDifferenceAbs
+        );
       } else if (extendedAmountDifference.greaterThan(0)) {
-        totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+        totalExtendedDeposit = totalExtendedDeposit.plus(
+          extendedAmountDifference
+        );
       }
 
       const vesuTargetAmount = vesuAmount.abs();
@@ -529,19 +641,31 @@ export class VesuExtendedMultiplierStrategy<
       let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
       const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
 
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
-      let calls: Call[] = [];
+      logger.info(
+        `${
+          VesuExtendedMultiplierStrategy.name
+        }::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`
+      );
       let transactionResults: TransactionResult[] = [];
 
       // Handle negative extendedAmount (initial withdrawal needed)
-      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+      if (
+        extendedAmount.isNegative() &&
+        extendedAmount
+          .abs()
+          .greaterThan(extendedAdapter.minimumExtendedMovementAmount)
+      ) {
         try {
-          const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+          const {
+            calls: extendedCalls,
+            status: extendedStatus,
+            transactionMetadata: extendedTransactionMetadata,
+          } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
               amount: extendedAmount.abs(),
-              cycleType: CycleType.INVESTMENT
+              cycleType: CycleType.INVESTMENT,
             },
             extendedAdapter,
             vesuAdapter
@@ -554,30 +678,73 @@ export class VesuExtendedMultiplierStrategy<
                 ...extendedTransactionMetadata,
                 transactionType: "DEPOSIT",
               },
-            })
+            });
           } else {
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", CycleType.INVESTMENT)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: extendedAmount.abs(),
+                },
+                "NONE",
+                CycleType.INVESTMENT
+              ),
+            ];
           }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
-          return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", CycleType.INVESTMENT)];
+          return [
+            this.createTransactionResult(
+              [],
+              false,
+              {
+                from: Protocols.EXTENDED.name,
+                to: Protocols.VAULT.name,
+                amount: extendedAmount.abs(),
+              },
+              "NONE",
+              CycleType.INVESTMENT
+            ),
+          ];
         }
       }
 
-      if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+      if (
+        vesuAmount.isNegative() &&
+        vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)
+      ) {
         try {
-          const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+          const {
+            calls: vesuCalls,
+            status: vesuStatus,
+            transactionMetadata: vesuTransactionMetadata,
+          } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
               amount: vesuAmount.abs(),
-              cycleType: CycleType.INVESTMENT
+              cycleType: CycleType.INVESTMENT,
             },
             extendedAdapter,
             vesuAdapter
           );
           if (!vesuStatus) {
-            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", CycleType.INVESTMENT)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.VESU.name,
+                  to: Protocols.EXTENDED.name,
+                  amount: vesuAmount.abs(),
+                },
+                "NONE",
+                CycleType.INVESTMENT
+              ),
+            ];
           }
           transactionResults.push({
             status: vesuStatus,
@@ -585,24 +752,46 @@ export class VesuExtendedMultiplierStrategy<
             transactionMetadata: {
               ...vesuTransactionMetadata,
               transactionType: "DEPOSIT",
-            }
-          })
+            },
+          });
         } catch (err) {
-          logger.error(`Failed moving assets to extended via vault allocator: ${err}`);
-          return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", CycleType.INVESTMENT)];
+          logger.error(
+            `Failed moving assets to extended via vault allocator: ${err}`
+          );
+          return [
+            this.createTransactionResult(
+              [],
+              false,
+              {
+                from: Protocols.VESU.name,
+                to: Protocols.EXTENDED.name,
+                amount: vesuAmount.abs(),
+              },
+              "NONE",
+              CycleType.INVESTMENT
+            ),
+          ];
         }
       }
 
       // Handle Extended adjustments based on calculated difference
-      if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+      if (
+        extendedAmountDifferenceAbs.greaterThan(
+          extendedAdapter.minimumExtendedMovementAmount
+        )
+      ) {
         if (extendedAmountDifference.greaterThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: extendedCalls,
+              status: extendedStatus,
+              transactionMetadata: extendedTransactionMetadata,
+            } = await this.moveAssets(
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VAULT.name,
                 amount: extendedAmountDifference,
-                cycleType: CycleType.INVESTMENT
+                cycleType: CycleType.INVESTMENT,
               },
               extendedAdapter,
               vesuAdapter
@@ -611,24 +800,54 @@ export class VesuExtendedMultiplierStrategy<
               transactionResults.push({
                 status: extendedStatus,
                 calls: extendedCalls,
-                transactionMetadata: extendedTransactionMetadata
-              })
+                transactionMetadata: extendedTransactionMetadata,
+              });
             } else {
-              logger.error(`Failed to move assets to extended - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", CycleType.INVESTMENT)];
+              logger.error(
+                `Failed to move assets to extended - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.VAULT.name,
+                    to: Protocols.EXTENDED.name,
+                    amount: extendedAmountDifference,
+                  },
+                  "NONE",
+                  CycleType.INVESTMENT
+                ),
+              ];
             }
           } catch (err) {
             logger.error(`Failed moving assets to extended: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", CycleType.INVESTMENT)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.VAULT.name,
+                  to: Protocols.EXTENDED.name,
+                  amount: extendedAmountDifference,
+                },
+                "NONE",
+                CycleType.INVESTMENT
+              ),
+            ];
           }
         } else if (extendedAmountDifference.lessThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: extendedCalls,
+              status: extendedStatus,
+              transactionMetadata: extendedTransactionMetadata,
+            } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
                 amount: extendedAmountDifferenceAbs,
-                cycleType: CycleType.INVESTMENT
+                cycleType: CycleType.INVESTMENT,
               },
               extendedAdapter,
               vesuAdapter
@@ -640,21 +859,51 @@ export class VesuExtendedMultiplierStrategy<
                 transactionMetadata: {
                   ...extendedTransactionMetadata,
                   transactionType: "DEPOSIT",
-                }
-              })
+                },
+              });
             } else {
-              logger.error(`Failed to withdraw from extended - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", CycleType.INVESTMENT)];
+              logger.error(
+                `Failed to withdraw from extended - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.EXTENDED.name,
+                    to: Protocols.VAULT.name,
+                    amount: extendedAmountDifferenceAbs,
+                  },
+                  "NONE",
+                  CycleType.INVESTMENT
+                ),
+              ];
             }
           } catch (err) {
             logger.error(`Failed moving assets from extended to vault: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", CycleType.INVESTMENT)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: extendedAmountDifferenceAbs,
+                },
+                "NONE",
+                CycleType.INVESTMENT
+              ),
+            ];
           }
         }
       }
 
       // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
-      if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+      if (
+        vesuAmountDifferenceAbs.greaterThan(
+          vesuAdapter.minimumVesuMovementAmount
+        )
+      ) {
         if (vesuAmountDifference.lessThanOrEqualTo(0)) {
           logger.warn(
             `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
@@ -662,19 +911,37 @@ export class VesuExtendedMultiplierStrategy<
         } else {
           // Move assets from Extended to Vault (which will then go to Vesu)
           try {
-            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: vesuCalls,
+              status: vesuStatus,
+              transactionMetadata: vesuTransactionMetadata,
+            } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
                 amount: vesuAmountDifference,
-                cycleType: CycleType.INVESTMENT
+                cycleType: CycleType.INVESTMENT,
               },
               extendedAdapter,
               vesuAdapter
             );
             if (!vesuStatus) {
-              logger.error(`Failed to move assets to vesu - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", CycleType.INVESTMENT)];
+              logger.error(
+                `Failed to move assets to vesu - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.EXTENDED.name,
+                    to: Protocols.VAULT.name,
+                    amount: vesuAmountDifference,
+                  },
+                  "NONE",
+                  CycleType.INVESTMENT
+                ),
+              ];
             }
             transactionResults.push({
               status: vesuStatus,
@@ -682,19 +949,42 @@ export class VesuExtendedMultiplierStrategy<
               transactionMetadata: {
                 ...vesuTransactionMetadata,
                 transactionType: "DEPOSIT",
-              }
-            })
+              },
+            });
           } catch (err) {
             logger.error(`Failed moving assets to vault: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", CycleType.INVESTMENT)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: vesuAmountDifference,
+                },
+                "NONE",
+                CycleType.INVESTMENT
+              ),
+            ];
           }
         }
       }
-
       return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
-      return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE", CycleType.INVESTMENT)];
+      return [
+        this.createTransactionResult(
+          [],
+          false,
+          {
+            from: Protocols.EXTENDED.name,
+            to: Protocols.VAULT.name,
+            amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
+          },
+          "NONE",
+          CycleType.INVESTMENT
+        ),
+      ];
     }
   }
 
@@ -705,7 +995,7 @@ export class VesuExtendedMultiplierStrategy<
     calls: Call[],
     status: boolean,
     params: { from: string; to: string; amount: Web3Number },
-    transactionType: 'DEPOSIT' | 'WITHDRAWAL' | 'NONE',
+    transactionType: "DEPOSIT" | "WITHDRAWAL" | "NONE",
     cycleType: CycleType
   ): TransactionResult {
     if (status) {
@@ -717,14 +1007,34 @@ export class VesuExtendedMultiplierStrategy<
           protocolTo: params.to,
           transactionType: transactionType,
           usdAmount: params.amount.abs().toFixed(),
-          status: 'PENDING',
-          cycleType: cycleType
-        }
+          status: "PENDING",
+          cycleType: cycleType,
+        },
       };
     }
-    return { calls: [], status: false, transactionMetadata: { protocolFrom: '', protocolTo: '', transactionType: 'DEPOSIT', usdAmount: '0', status: 'FAILED', cycleType: cycleType } };
+    return {
+      calls: [],
+      status: false,
+      transactionMetadata: {
+        protocolFrom: "",
+        protocolTo: "",
+        transactionType: "DEPOSIT",
+        usdAmount: "0",
+        status: "FAILED",
+        cycleType: cycleType,
+      },
+    };
   }
 
+  /**
+   * This method is used to move assets between protocols
+   * @param params - The parameters for the move assets operation
+   * @param extendedAdapter - The extended adapter
+   * @param vesuAdapter - The vesu adapter
+   * @returns The transaction result
+   * If Extended amount is greater than amount of withdrawal from extended, then we need to open a long position
+   * so that the amount of withdrawal from extended is fullfilled
+   */
   async moveAssets(
     params: {
       amount: Web3Number;
@@ -733,7 +1043,7 @@ export class VesuExtendedMultiplierStrategy<
       cycleType: CycleType;
     },
     extendedAdapter: ExtendedAdapter,
-    vesuAdapter: VesuMultiplyAdapter,
+    vesuAdapter: VesuMultiplyAdapter
   ): Promise<TransactionResult> {
     try {
       // Validate amount is positive before starting operations
@@ -741,40 +1051,53 @@ export class VesuExtendedMultiplierStrategy<
         logger.error(
           `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
         );
-        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        return this.createTransactionResult(
+          [],
+          false,
+          params,
+          "NONE",
+          params.cycleType
+        );
       }
 
       // Check minimum movement amounts before starting operations
-      const amountAbs = params.amount.abs();
-      if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
-        if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
-          logger.warn(
-            `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
-          );
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
-        }
-      }
-      if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
-        if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
-          logger.warn(
-            `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
-          );
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
-        }
-      }
+      // const amountAbs = params.amount.abs();
+      // if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
+      //   if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
+      //     logger.warn(
+      //       `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
+      //     );
+      //     return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      //   }
+      // }
+      // if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
+      //   if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
+      //     logger.warn(
+      //       `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
+      //     );
+      //     return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      //   }
+      // }
 
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        return this.createTransactionResult(
+          [],
+          false,
+          params,
+          "NONE",
+          params.cycleType
+        );
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
-      const {
-        collateralPrice,
-      } = await this.getAssetPrices();
+      const { collateralPrice } = await this.getAssetPrices();
 
-      if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VAULT.name) {
+      if (
+        params.to === Protocols.EXTENDED.name &&
+        params.from === Protocols.VAULT.name
+      ) {
         const proofsInfo = extendedAdapter.getProofs(
           true,
           this.getMerkleTree()
@@ -786,84 +1109,204 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
-      } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "DEPOSIT",
+          params.cycleType
+        );
+      } else if (
+        params.to === Protocols.VAULT.name &&
+        params.from === Protocols.EXTENDED.name
+      ) {
         const extendedLeverage = calculateExtendedLevergae();
-        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        const extendedHoldings =
+          await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
           USDC_TOKEN_DECIMALS
         );
-        logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+        logger.info(
+          `${
+            VesuExtendedMultiplierStrategy.name
+          }::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
+        );
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
-          const leftAmountAfterWithdrawalAmountInAccount = params.amount.abs().minus(extendedHoldingAmount);
-          logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`);
-          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
-          const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
-            extendedLeverage.toString(),
-            btcAmount.toNumber(),
-            OrderSide.BUY
-          ) : await extendedAdapter.createOrder(
-            extendedLeverage.toString(),
-            0.000034, // just in case amount falls short then we need to create a withdrawal
-            OrderSide.BUY
-          )
+          const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
+            Math.ceil(
+              params.amount.abs().minus(extendedHoldingAmount).toNumber()
+            ),
+            USDC_TOKEN_DECIMALS
+          );
+          logger.info(
+            `${
+              VesuExtendedMultiplierStrategy.name
+            }::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
+          );
+          let priceOfBTC;
+          const { ask, bid, status } =
+            await extendedAdapter.fetchOrderBookBTCUSDC();
+          const price = ask.plus(bid).dividedBy(2);
+          if (status) {
+            priceOfBTC = price;
+          } else {
+            logger.error(`error fetching order book btc usdc: ${status}`);
+            priceOfBTC = collateralPrice.price;
+          }
+          const btcAmount =
+            leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          /**
+           * If amount for withdrawal is greater than the amount in extended available for withdrawal,
+           * then we need to open a long position depending on the difference between the two
+           */
+          const openLongPosition = btcAmount
+            .multipliedBy(3)
+            .greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)
+            ? await extendedAdapter.createOrder(
+                extendedLeverage.toString(),
+                btcAmount.toNumber(),
+                OrderSide.BUY
+              )
+            : await extendedAdapter.createOrder(
+                extendedLeverage.toString(),
+                0.000034, // just in case amount falls short then we need to create a withdrawal
+                OrderSide.BUY
+              );
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
           }
-          const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
-          if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
-            logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
-            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          const updatedHoldings =
+            await extendedAdapter.getExtendedDepositAmount();
+          if (
+            !updatedHoldings ||
+            new Web3Number(
+              updatedHoldings.availableForWithdrawal,
+              USDC_TOKEN_DECIMALS
+            ).lessThan(params.amount.abs())
+          ) {
+            logger.error(
+              `Insufficient balance after opening position. Available: ${
+                updatedHoldings?.availableForWithdrawal
+              }, Needed: ${params.amount.abs()}`
+            );
+            return this.createTransactionResult(
+              [],
+              false,
+              params,
+              "NONE",
+              params.cycleType
+            );
           }
         }
         const {
           status: withdrawalFromExtendedStatus,
           receivedTxnHash: withdrawalFromExtendedTxnHash,
-        } =
-          await extendedAdapter.withdrawFromExtended(params.amount);
+        } = await extendedAdapter.withdrawFromExtended(params.amount);
         /**
          * This logic needs fixing
          */
-        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        logger.info(
+          `withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`
+        );
         if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           /**
-          * We need to move assets from my wallet back to vault contract
-          */
-          const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-          logger.info(`extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`);
-          await new Promise(resolve => setTimeout(resolve, 5000));
-          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+           * We need to move assets from my wallet back to vault contract
+           */
+          const extendedHoldings =
+            await extendedAdapter.getExtendedDepositAmount();
+          logger.info(
+            `extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`
+          );
+          await new Promise((resolve) => setTimeout(resolve, 5000));
+          const { calls, status } = await this.moveAssetsToVaultAllocator(
+            params.amount,
+            extendedAdapter
+          );
           if (calls.length > 0 && status) {
-            return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
+            return this.createTransactionResult(
+              calls,
+              true,
+              params,
+              "WITHDRAWAL",
+              params.cycleType
+            );
           } else {
             /**
              * This is a fallback scenario, where the funds were withdrawn from extended, but didn't get transferred to the wallet
              * We need to return a successful transaction result, but with no calls
              * Db update will be handled by the risk engine for this specific case
              */
-            return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
+            return this.createTransactionResult(
+              [],
+              true,
+              params,
+              "WITHDRAWAL",
+              params.cycleType
+            );
           }
-        } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
-          logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
-          return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
+        } else if (
+          withdrawalFromExtendedStatus &&
+          !withdrawalFromExtendedTxnHash
+        ) {
+          logger.error(
+            "withdrawal from extended successful, but funds didn't get transferred to the wallet"
+          );
+          return this.createTransactionResult(
+            [],
+            true,
+            params,
+            "WITHDRAWAL",
+            params.cycleType
+          );
         } else {
           logger.error("withdrawal from extended failed");
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
-      } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
-        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, PositionTypeAvnuExtended.CLOSE);
+      } else if (
+        params.to === Protocols.VAULT.name &&
+        params.from === Protocols.VESU.name
+      ) {
+        const isPriceDifferenceBetweenAvnuAndExtended =
+          await this.checkPriceDifferenceBetweenAvnuAndExtended(
+            extendedAdapter,
+            vesuAdapter,
+            avnuAdapter,
+            PositionTypeAvnuExtended.CLOSE
+          );
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
-          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          logger.warn(
+            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
-        //withdraw from vesu 
+        //withdraw from vesu
         const vesuAmountInBTC = new Web3Number(
-          params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
+          params.amount
+            .dividedBy(collateralPrice.price)
+            .toFixed(WBTC_TOKEN_DECIMALS),
           collateralToken.decimals
         );
         const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
@@ -874,19 +1317,45 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(call);
-        const swapProofsInfo = avnuAdapter.getProofs(false, this.getMerkleTree());
+        const swapProofsInfo = avnuAdapter.getProofs(
+          false,
+          this.getMerkleTree()
+        );
         const swapProofGroups = swapProofsInfo.proofs;
         const swapCall = this.getManageCall(
           swapProofGroups,
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
-      } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
-        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, PositionTypeAvnuExtended.CLOSE);
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "WITHDRAWAL",
+          params.cycleType
+        );
+      } else if (
+        params.to === Protocols.EXTENDED.name &&
+        params.from === Protocols.VESU.name
+      ) {
+        const isPriceDifferenceBetweenAvnuAndExtended =
+          await this.checkPriceDifferenceBetweenAvnuAndExtended(
+            extendedAdapter,
+            vesuAdapter,
+            avnuAdapter,
+            PositionTypeAvnuExtended.CLOSE
+          );
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
-          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          logger.warn(
+            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -900,7 +1369,10 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(call);
-        const swapProofsInfo = avnuAdapter.getProofs(false, this.getMerkleTree());
+        const swapProofsInfo = avnuAdapter.getProofs(
+          false,
+          this.getMerkleTree()
+        );
         const swapProofGroups = swapProofsInfo.proofs;
         const swapCall = this.getManageCall(
           swapProofGroups,
@@ -918,13 +1390,33 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "DEPOSIT",
+          params.cycleType
+        );
       }
-      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
-      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      logger.error(
+        `Unsupported assets movement: ${params.from} to ${params.to}`
+      );
+      return this.createTransactionResult(
+        [],
+        false,
+        params,
+        "NONE",
+        params.cycleType
+      );
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      return this.createTransactionResult(
+        [],
+        false,
+        params,
+        "NONE",
+        params.cycleType
+      );
     }
   }
 
@@ -933,14 +1425,33 @@ export class VesuExtendedMultiplierStrategy<
       /**
        * Just a demo function, not used in the risk engine
        */
-      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", CycleType.INVESTMENT);
+      return this.createTransactionResult(
+        [],
+        false,
+        {
+          from: Protocols.VAULT.name,
+          to: Protocols.VAULT.name,
+          amount: new Web3Number(0, 0),
+        },
+        "NONE",
+        CycleType.INVESTMENT
+      );
     } catch (err) {
       logger.error(`error handling deposit: ${err}`);
-      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", CycleType.INVESTMENT);
+      return this.createTransactionResult(
+        [],
+        false,
+        {
+          from: Protocols.VAULT.name,
+          to: Protocols.VAULT.name,
+          amount: new Web3Number(0, 0),
+        },
+        "NONE",
+        CycleType.INVESTMENT
+      );
     }
   }
 
-
   /**
    * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
    * @param extendedAdapter - the extended adapter
@@ -949,13 +1460,18 @@ export class VesuExtendedMultiplierStrategy<
    * @param positionType - the position type (open or close)
    * @returns true if the price difference is within the acceptable range, false otherwise
    */
-  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter, positionType: PositionTypeAvnuExtended): Promise<boolean> {
-    const {
-      ask, bid
-    } = await extendedAdapter.fetchOrderBookBTCUSDC();
+  async checkPriceDifferenceBetweenAvnuAndExtended(
+    extendedAdapter: ExtendedAdapter,
+    vesuAdapter: VesuMultiplyAdapter,
+    avnuAdapter: AvnuAdapter,
+    positionType: PositionTypeAvnuExtended
+  ): Promise<boolean> {
+    const { ask, bid } = await extendedAdapter.fetchOrderBookBTCUSDC();
     const price = ask.plus(bid).dividedBy(2);
     const btcToken = vesuAdapter.config.supportedPositions[0].asset;
-    const btcPriceAvnu = await avnuAdapter.getPriceOfToken(btcToken.address.toString());
+    const btcPriceAvnu = await avnuAdapter.getPriceOfToken(
+      btcToken.address.toString()
+    );
 
     if (!btcPriceAvnu) {
       logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
@@ -963,19 +1479,34 @@ export class VesuExtendedMultiplierStrategy<
     }
     logger.info(`price: ${price}`);
     logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
-    const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+    const priceDifference = new Web3Number(
+      price.minus(btcPriceAvnu).toFixed(2),
+      0
+    );
     logger.info(`priceDifference: ${priceDifference}`);
     if (priceDifference.isNegative()) {
       return false;
     }
     if (positionType === PositionTypeAvnuExtended.OPEN) {
-      logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
-      const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen); // 500 for now
+      logger.info(
+        `price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${
+          avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen
+        }`
+      );
+      const result = priceDifference.greaterThanOrEqualTo(
+        avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen
+      ); // 500 for now
       logger.info(`result: ${result}`);
       return result;
     } else {
-      logger.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-      const result = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing); // 1000 for now
+      logger.info(
+        `price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${
+          avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing
+        }`
+      );
+      const result = priceDifference.lessThanOrEqualTo(
+        avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing
+      ); // 1000 for now
       logger.info(`result: ${result}`);
       return result;
     }
@@ -989,16 +1520,30 @@ export class VesuExtendedMultiplierStrategy<
   async handleWithdraw(amount: Web3Number): Promise<TransactionResult[]> {
     try {
       const usdcBalanceVaultAllocator = await this.getUnusedBalance();
-      const usdcBalanceDifference = amount.plus(BUFFER_USDC_IN_WITHDRAWAL).minus(usdcBalanceVaultAllocator.usdValue);
+      const usdcBalanceDifference = amount
+        .plus(BUFFER_USDC_IN_WITHDRAWAL)
+        .minus(usdcBalanceVaultAllocator.usdValue);
       logger.info(`usdcBalanceDifference, ${usdcBalanceDifference.toNumber()}`);
       let calls: Call[] = [];
       let status: boolean = true;
       if (usdcBalanceDifference.lessThan(0)) {
         const withdrawCall = await this.getBringLiquidityCall({
-          amount: usdcBalanceVaultAllocator.amount
-        })
+          amount: usdcBalanceVaultAllocator.amount,
+        });
         calls.push(withdrawCall);
-        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "WITHDRAWAL", CycleType.WITHDRAWAL)];
+        return [
+          this.createTransactionResult(
+            calls,
+            true,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount: amount,
+            },
+            "WITHDRAWAL",
+            CycleType.WITHDRAWAL
+          ),
+        ];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -1007,19 +1552,41 @@ export class VesuExtendedMultiplierStrategy<
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount: amount,
+            },
+            "NONE",
+            CycleType.WITHDRAWAL
+          ),
+        ];
       }
       let transactionResults: TransactionResult[] = [];
       const { collateralTokenAmount } =
         await vesuAdapter.vesuAdapter.getAssetPrices();
-      const {
-        collateralPrice
-      } = await this.getAssetPrices();
+      const { collateralPrice } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
       if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount: amount,
+            },
+            "NONE",
+            CycleType.WITHDRAWAL
+          ),
+        ];
       }
       const amountDistributionForWithdrawal =
         await calculateAmountDistributionForWithdrawal(
@@ -1033,17 +1600,33 @@ export class VesuExtendedMultiplierStrategy<
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount: amount,
+            },
+            "NONE",
+            CycleType.WITHDRAWAL
+          ),
+        ];
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
 
       if (status && vesu_amount.greaterThan(0)) {
-        const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+        const {
+          calls: vesuCalls,
+          status: vesuStatus,
+          transactionMetadata: vesuTransactionMetadata,
+        } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
             to: Protocols.VAULT.name,
-            cycleType: CycleType.WITHDRAWAL
+            cycleType: CycleType.WITHDRAWAL,
           },
           extendedAdapter,
           vesuAdapter
@@ -1052,16 +1635,20 @@ export class VesuExtendedMultiplierStrategy<
         transactionResults.push({
           status: vesuStatus,
           calls: vesuCalls,
-          transactionMetadata: vesuTransactionMetadata
-        })
+          transactionMetadata: vesuTransactionMetadata,
+        });
       }
       if (status && extended_amount.greaterThan(0)) {
-        const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+        const {
+          calls: extendedCalls,
+          status: extendedStatus,
+          transactionMetadata: extendedTransactionMetadata,
+        } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
             to: Protocols.VAULT.name,
-            cycleType: CycleType.WITHDRAWAL
+            cycleType: CycleType.WITHDRAWAL,
           },
           extendedAdapter,
           vesuAdapter
@@ -1071,16 +1658,30 @@ export class VesuExtendedMultiplierStrategy<
           transactionResults.push({
             status: extendedStatus,
             calls: extendedCalls,
-            transactionMetadata: extendedTransactionMetadata
-          })
+            transactionMetadata: extendedTransactionMetadata,
+          });
         } else {
-          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
+          logger.error(
+            "error moving assets to vault: extendedStatus: ${extendedStatus}"
+          );
+          return [
+            this.createTransactionResult(
+              [],
+              status,
+              {
+                from: Protocols.VAULT.name,
+                to: Protocols.NONE.name,
+                amount: amount,
+              },
+              "NONE",
+              CycleType.WITHDRAWAL
+            ),
+          ];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
-        amount: amount
-      })
+        amount: amount,
+      });
       logger.info("withdraw call", withdrawCall);
       transactionResults.push({
         status: status,
@@ -1090,18 +1691,34 @@ export class VesuExtendedMultiplierStrategy<
           protocolTo: Protocols.NONE.name,
           transactionType: "WITHDRAWAL",
           usdAmount: amount.toFixed(),
-          status: 'PENDING',
-          cycleType: CycleType.WITHDRAWAL
-        }
-      })
+          status: "PENDING",
+          cycleType: CycleType.WITHDRAWAL,
+        },
+      });
       return transactionResults;
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
+      return [
+        this.createTransactionResult(
+          [],
+          false,
+          {
+            from: Protocols.VAULT.name,
+            to: Protocols.NONE.name,
+            amount: amount,
+          },
+          "NONE",
+          CycleType.WITHDRAWAL
+        ),
+      ];
     }
   }
 
-  async getAUM(): Promise<{ net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[] }> {
+  async getAUM(): Promise<{
+    net: SingleTokenInfo;
+    prevAum: Web3Number;
+    splits: PositionInfo[];
+  }> {
     const allPositions: PositionInfo[] = [];
     for (let adapter of this.metadata.additionalInfo.adapters) {
       const positions = await adapter.adapter.getPositions();
@@ -1125,34 +1742,49 @@ export class VesuExtendedMultiplierStrategy<
       usdValue: netAUM.toNumber() * assetPrice.price,
       apy: { apy: netAUM.toNumber() * assetPrice.price, type: APYType.BASE },
       remarks: AUMTypes.FINALISED,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE, // just placeholder
     };
 
     const estimatedAUMDelta: PositionInfo = {
       tokenInfo: this.asset(),
-      amount: Web3Number.fromWei('0', this.asset().decimals),
+      amount: Web3Number.fromWei("0", this.asset().decimals),
       usdValue: 0,
       apy: { apy: 0, type: APYType.BASE },
       remarks: AUMTypes.DEFISPRING,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE, // just placeholder
     };
 
     return {
       net: {
         tokenInfo: this.asset(),
         amount: netAUM,
-        usdValue: netAUM.toNumber() * assetPrice.price
-      }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]
+        usdValue: netAUM.toNumber() * assetPrice.price,
+      },
+      prevAum: prevAum,
+      splits: [realAUM, estimatedAUMDelta],
     };
   }
 
-  async processTransactionDataFromSDK(txnData: TransactionResult<any>[]): Promise<{ callsToBeExecutedFinal: Call[], txnMetadata: TransactionMetadata[] } | null> {
+  async processTransactionDataFromSDK(
+    txnData: TransactionResult<any>[]
+  ): Promise<{
+    callsToBeExecutedFinal: Call[];
+    txnMetadata: TransactionMetadata[];
+  } | null> {
     try {
-      const txnsToBeExecuted = txnData.filter(txn => {
-        return txn.transactionMetadata.transactionType !== 'NONE' && txn.transactionMetadata.protocolFrom !== "" && txn.transactionMetadata.protocolTo !== "";
-      })
-      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap(txn => txn.calls);
-      const txnMetadata = txnsToBeExecuted.map(txn => txn.transactionMetadata);
+      const txnsToBeExecuted = txnData.filter((txn) => {
+        return (
+          txn.transactionMetadata.transactionType !== "NONE" &&
+          txn.transactionMetadata.protocolFrom !== "" &&
+          txn.transactionMetadata.protocolTo !== ""
+        );
+      });
+      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap(
+        (txn) => txn.calls
+      );
+      const txnMetadata = txnsToBeExecuted.map(
+        (txn) => txn.transactionMetadata
+      );
       return { callsToBeExecutedFinal, txnMetadata };
     } catch (err) {
       logger.error(`error processing transaction data from SDK: ${err}`);
@@ -1160,18 +1792,23 @@ export class VesuExtendedMultiplierStrategy<
     }
   }
 
-  async processTransactionMetadata(txnMetadata: TransactionMetadata[], extendedIntentFulfilled: boolean): Promise<TransactionMetadata[] | null> {
+  async processTransactionMetadata(
+    txnMetadata: TransactionMetadata[],
+    extendedIntentFulfilled: boolean
+  ): Promise<TransactionMetadata[] | null> {
     try {
-      const txnMetadataNew = txnMetadata.map(txn => {
-        const isExtendedProtocol = txn.protocolFrom === Protocols.EXTENDED.name || txn.protocolTo === Protocols.EXTENDED.name;
+      const txnMetadataNew = txnMetadata.map((txn) => {
+        const isExtendedProtocol =
+          txn.protocolFrom === Protocols.EXTENDED.name ||
+          txn.protocolTo === Protocols.EXTENDED.name;
         // Only update status for extended protocol transactions since thsoe only cause delays
         if (isExtendedProtocol) {
-          txn.status = extendedIntentFulfilled ? 'COMPLETED' : 'PENDING';
+          txn.status = extendedIntentFulfilled ? "COMPLETED" : "PENDING";
         } else {
-          txn.status = 'COMPLETED';
+          txn.status = "COMPLETED";
         }
         return txn;
-      })
+      });
       return txnMetadataNew;
     } catch (err) {
       logger.error(`error processing transaction data from SDK: ${err}`);
@@ -1185,23 +1822,43 @@ export class VesuExtendedMultiplierStrategy<
     if (!vesuAdapter || !extendedAdapter) {
       return new Web3Number(0, 0);
     }
-    const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+    const extendedFundingRate = new Web3Number(
+      (await extendedAdapter.getNetAPY()).toFixed(4),
+      0
+    );
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
     if (!extendedPositions || extendedPositions.length === 0) {
       logger.info(`no extended positions found`);
       return new Web3Number(0, 0);
     }
-    const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+    const extendePositionSizeUSD = new Web3Number(
+      extendedPositions[0].value || 0,
+      0
+    );
     const vesuPositions = await vesuAdapter.getPositions();
     const vesuSupplyApy = vesuPositions[0].apy.apy;
-    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
-    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)
-     const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
+    const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
     const num2 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
-    const num3 = vesuDebtSizeUSD.abs()
+    const num3 = vesuDebtSizeUSD.abs();
     const maxBorrowApy = num1.plus(num2).minus(0.1).dividedBy(num3);
-    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
-    return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuMaxBorrowableAmount =
+      await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(
+        this.config,
+        vesuAdapter.config.debt,
+        maxBorrowApy.toNumber()
+      );
+    return new Web3Number(
+      vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
   }
 
   async getVesuHealthFactors(): Promise<number[]> {
@@ -1211,83 +1868,124 @@ export class VesuExtendedMultiplierStrategy<
       return [0, 0];
     }
     const vesuPositions = await vesuAdapter.getPositions();
-    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
-    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0
+    );
     const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
     logger.info(`actualLtv: ${actualLtv.toNumber()}`);
-    const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
-    const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+    const maxLtv = new Web3Number(
+      await vesuAdapter.vesuAdapter.getLTVConfig(this.config),
+      4
+    );
+    const healthFactor = new Web3Number(
+      maxLtv.dividedBy(actualLtv).toFixed(4),
+      4
+    );
     logger.info(`healthFactor: ${healthFactor.toNumber()}`);
     const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
     if (!extendedBalance) {
       return [0, 0];
     }
-    const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+    const extendedLeverage = new Web3Number(
+      (Number(extendedBalance.marginRatio) * 100).toFixed(4),
+      4
+    );
     logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
     return [healthFactor.toNumber(), extendedLeverage.toNumber()];
   }
 
-  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
+  async netAPY(): Promise<{
+    net: number;
+    splits: { apy: number; id: string }[];
+  }> {
     const allPositions: PositionInfo[] = [];
     for (let adapter of this.metadata.additionalInfo.adapters) {
-        if(adapter.adapter.name !== ExtendedAdapter.name){
-          let positions = await adapter.adapter.getPositions();
-          if(positions.length > 0){
-            allPositions.push(...positions);
-          }
+      if (adapter.adapter.name !== ExtendedAdapter.name) {
+        let positions = await adapter.adapter.getPositions();
+        if (positions.length > 0) {
+          allPositions.push(...positions);
         }
       }
-    const extendedAdapter =await this.getExtendedAdapter()
-    if(!extendedAdapter){
+    }
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!extendedAdapter) {
       return {
         net: 0,
-        splits: []
-      }
+        splits: [],
+      };
     }
-    let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
-    vesuPositions.map((item) =>{
+    let vesuPositions = allPositions.filter(
+      (item) => item.protocol === Protocols.VESU
+    );
+    vesuPositions.map((item) => {
       item.apy.apy = item.apy.apy * 0.1;
-    })
+    });
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
-    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
-    if(!extendedPositions || !usdcToken){
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    );
+    if (!extendedPositions || !usdcToken) {
       return {
         net: 0,
-        splits: []
-      }
+        splits: [],
+      };
     }
     const extendedPosition = extendedPositions[0] || 0;
-    const extendedEquity = (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+    const extendedEquity =
+      (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
     const extendedApy = await extendedAdapter.getNetAPY();
-    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
-    console.log(totalHoldingsUSDValue)
-    const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
-    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
-    console.log(weightedAPYs)
+    const totalHoldingsUSDValue =
+      allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) +
+      Number(extendedEquity);
+    console.log(totalHoldingsUSDValue);
+    const extendedPositionSizeMultipliedByApy =
+      Number(extendedPosition.value) * extendedApy;
+    let weightedAPYs =
+      allPositions.reduce(
+        (acc, curr) => acc + curr.apy.apy * curr.usdValue,
+        0
+      ) + extendedPositionSizeMultipliedByApy;
+    console.log(weightedAPYs);
     const netAPY = weightedAPYs / totalHoldingsUSDValue;
-    console.log(netAPY)
+    console.log(netAPY);
     allPositions.push({
       tokenInfo: usdcToken,
       amount: new Web3Number(extendedPosition.size, 0),
       usdValue: Number(extendedEquity),
       apy: { apy: extendedApy, type: APYType.BASE },
       remarks: AUMTypes.FINALISED,
-      protocol: Protocols.EXTENDED 
-    })
+      protocol: Protocols.EXTENDED,
+    });
     return {
       net: netAPY,
-      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+      splits: allPositions.map((p) => ({
+        apy: p.apy.apy,
+        id: p.remarks ?? "",
+      })),
     };
   }
 
-  async getWalletHoldings(): Promise<{
-    tokenInfo: TokenInfo,
-    amount: Web3Number,
-    usdValue: number
-  }[]> {
-    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
-    const wbtcToken = Global.getDefaultTokens().find(token => token.symbol === "WBTC");
-    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
+  async getWalletHoldings(): Promise<
+    {
+      tokenInfo: TokenInfo;
+      amount: Web3Number;
+      usdValue: number;
+    }[]
+  > {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    const wbtcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "WBTC"
+    );
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    );
     if (!usdceToken || !wbtcToken || !usdcToken) {
       return [];
     }
@@ -1309,23 +2007,29 @@ export class VesuExtendedMultiplierStrategy<
     );
     const price = await this.pricer.getPrice(usdceToken.symbol);
     const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
-    const usdceUsdValue = Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
-    const usdcUsdValue = Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
-    const wbtcUsdValue = Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
-    return [{
-      tokenInfo: usdceToken,
-      amount: usdceWalletBalance,
-      usdValue: usdceUsdValue
-    },
-    {
-      tokenInfo: usdcToken,
-      amount: usdcWalletBalance,
-      usdValue: usdcUsdValue
-    }, {
-      tokenInfo: wbtcToken,
-      amount: wbtcWalletBalance,
-      usdValue: wbtcUsdValue
-    }];
+    const usdceUsdValue =
+      Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+    const usdcUsdValue =
+      Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
+    const wbtcUsdValue =
+      Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+    return [
+      {
+        tokenInfo: usdceToken,
+        amount: usdceWalletBalance,
+        usdValue: usdceUsdValue,
+      },
+      {
+        tokenInfo: usdcToken,
+        amount: usdcWalletBalance,
+        usdValue: usdcUsdValue,
+      },
+      {
+        tokenInfo: wbtcToken,
+        amount: wbtcWalletBalance,
+        usdValue: wbtcUsdValue,
+      },
+    ];
   }
 }
 
@@ -1341,7 +2045,7 @@ function getLooperSettings(
   minimumVesuMovementAmount: number,
   minimumExtendedRetriesDelayForOrderStatus: number,
   minimumExtendedPriceDifferenceForSwapOpen: number,
-  maximumExtendedPriceDifferenceForSwapClosing: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number
 ) {
   vaultSettings.leafAdapters = [];
 
@@ -1370,15 +2074,15 @@ function getLooperSettings(
     avnuContract: AVNU_MIDDLEWARE,
     slippage: 0.01,
     baseUrl: AVNU_QUOTE_URL,
-    minimumExtendedPriceDifferenceForSwapOpen: minimumExtendedPriceDifferenceForSwapOpen,
-    maximumExtendedPriceDifferenceForSwapClosing: maximumExtendedPriceDifferenceForSwapClosing,
+    minimumExtendedPriceDifferenceForSwapOpen:
+      minimumExtendedPriceDifferenceForSwapOpen,
+    maximumExtendedPriceDifferenceForSwapClosing:
+      maximumExtendedPriceDifferenceForSwapClosing,
   });
 
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
-    supportedPositions: [
-      { asset: usdcToken, isDebt: true },
-    ],
+    supportedPositions: [{ asset: usdcToken, isDebt: true }],
     vaultIdExtended: vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
     extendedBackendWriteUrl: extendedBackendWriteUrl,
@@ -1441,11 +2145,11 @@ function getLooperSettings(
   });
 
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() =>
-    vesuMultiplyAdapter.getWithdrawLeaf()
+    extendedAdapter.getSwapFromLegacyLeaf()
   );
-  vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(
@@ -1466,7 +2170,6 @@ function getLooperSettings(
   return vaultSettings;
 }
 
-
 function getDescription(tokenSymbol: string, underlyingSymbol: string) {
   return VaultDescription(tokenSymbol, underlyingSymbol);
 }
@@ -1486,26 +2189,64 @@ export default function VaultDescription(
 
   return (
     <div style={containerStyle}>
-      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>Liquidation risk managed leverged {lstSymbol} Vault</h1>
+      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>
+        Liquidation risk managed leverged {lstSymbol} Vault
+      </h1>
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault, auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by borrow {underlyingSymbol}. Borrowed amount
-        is swapped to {lstSymbol} to create leverage. Depositors receive vault shares that
-        represent a proportional claim on the underlying assets and accrued yield.
+        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault,
+        auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by
+        borrow {underlyingSymbol}. Borrowed amount is swapped to {lstSymbol} to
+        create leverage. Depositors receive vault shares that represent a
+        proportional claim on the underlying assets and accrued yield.
       </p>
 
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This vault uses Vesu for lending and borrowing. The oracle used by this pool is a {highlightTextWithLinks("conversion rate oracle", [{ highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate" }])}
-        {" "}which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.
+        This vault uses Vesu for lending and borrowing. The oracle used by this
+        pool is a{" "}
+        {highlightTextWithLinks("conversion rate oracle", [
+          {
+            highlight: "conversion rate oracle",
+            link: "https://docs.pragma.build/starknet/development#conversion-rate",
+          },
+        ])}{" "}
+        which is resilient to liquidity issues and price volatility, hence
+        reducing the risk of liquidation. However, overtime, if left
+        un-monitored, debt can increase enough to trigger a liquidation. But no
+        worries, our continuous monitoring systems look for situations with
+        reduced health factor and balance collateral/debt to bring it back to
+        safe levels. With Troves, you can have a peaceful sleep.
       </p>
 
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Withdrawals:</strong> Requests can take up to <strong>1-2 hours</strong> to process as the vault unwinds and settles routing.
+          <strong>Withdrawals:</strong> Requests can take up to{" "}
+          <strong>1-2 hours</strong> to process as the vault unwinds and settles
+          routing.
         </p>
       </div>
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited Tokens remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on Yield token's APY, its only on added gain.
+          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are
+          gradually increased over time. Until caps are raised, deposited Tokens
+          remain in the vault, generating a shared net return for all
+          depositors. There is no additional fee taken by Troves on Yield
+          token's APY, its only on added gain.
         </p>
       </div>
       {/* <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
@@ -1518,11 +2259,21 @@ export default function VaultDescription(
 }
 
 const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
-  vaultAddress: ContractAddr.from("0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"),
-  manager: ContractAddr.from("0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"),
-  vaultAllocator: ContractAddr.from("0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"),
-  redeemRequestNFT: ContractAddr.from("0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"),
-  aumOracle: ContractAddr.from("0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"),
+  vaultAddress: ContractAddr.from(
+    "0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"
+  ),
+  manager: ContractAddr.from(
+    "0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"
+  ),
+  aumOracle: ContractAddr.from(
+    "0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
@@ -1534,34 +2285,88 @@ const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
     "0.001",
     Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!.decimals
   ),
-  borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "WBTC")!],
+  borrowable_assets: [
+    Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!,
+  ],
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
   walletAddress: WALLET_ADDRESS,
-}
+};
 
-export const VesuExtendedTestStrategies = (extendedBackendReadUrl: string, extendedBackendWriteUrl: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
+export const VesuExtendedTestStrategies = (
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
+  vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number
+): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
   return [
-    getStrategySettingsVesuExtended('WBTC', 'USDC', re7UsdcPrimeDevansh, false, false, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
-  ]
-}
-
-
-
-function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendReadUrl: string, extendedBackendWriteUrl: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings> {
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      re7UsdcPrimeDevansh,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
+    ),
+  ];
+};
+
+function getStrategySettingsVesuExtended(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  addresses: VesuExtendedStrategySettings,
+  isPreview: boolean = false,
+  isLST: boolean,
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
+  vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number
+): IStrategyMetadata<VesuExtendedStrategySettings> {
   return {
     name: `Extended Test ${underlyingSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
     address: addresses.vaultAddress,
     launchBlock: 0,
-    type: 'Other',
-    depositTokens: [Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!],
-    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
+    type: "Other",
+    depositTokens: [
+      Global.getDefaultTokens().find(
+        (token) => token.symbol === underlyingSymbol
+      )!,
+    ],
+    additionalInfo: getLooperSettings(
+      lstSymbol,
+      underlyingSymbol,
+      addresses,
+      VesuPools.Re7USDCPrime,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
+    ),
     risk: {
       riskFactor: _riskFactor,
       netRisk:
         _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
         _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-      notARisks: getNoRiskTags(_riskFactor)
+      notARisks: getNoRiskTags(_riskFactor),
     },
     auditUrl: AUDIT_URL,
     protocols: [Protocols.ENDUR, Protocols.VESU],
@@ -1570,6 +2375,8 @@ function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: st
     faqs: getFAQs(lstSymbol, underlyingSymbol, isLST),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
     isPreview: isPreview,
-    apyMethodology: isLST ? 'Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.' : 'Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.'
-  }
-}
+    apyMethodology: isLST
+      ? "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown."
+      : "Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
+  };
+}