@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

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

@@ -0,0 +1,1486 @@
+import { getContractDetails, UniversalStrategySettings, PositionTypeAvnuExtended } from "../universal-strategy";
+import { Web3Number } from "@/dataTypes";
+import { ContractAddr } from "@/dataTypes";
+import { SVKStrategy } from "../svk-strategy";
+import { VesuBorrowSupplyAdapter } from "../universal-adapters/vesu-borrow-adapter";
+import { getNoRiskTags, IStrategyMetadata, TokenInfo } from "@/interfaces";
+import { IConfig } from "@/interfaces";
+import { LIMIT_BALANCE, LIMIT_BALANCE_VALUE, MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP, WBTC_TOKEN_ADDRESS } from "../vesu-extended-strategy/utils/constants";
+import { VesuMultiplyAdapter, VesuPools } from "../universal-adapters";
+import { PricerBase } from "@/modules"
+import { AUMTypes } from "../universal-strategy";
+import { UNIVERSAL_MANAGE_IDS } from "../universal-strategy";
+import { BaseAdapterConfig } from "../universal-adapters";
+import { Global } from "@/global";
+import { highlightTextWithLinks } from "@/interfaces";
+import { PricerFromApi } from "@/modules";
+import { APYType } from "../universal-adapters";
+import { getMainnetConfig } from "@/interfaces";
+import { AVNU_QUOTE_URL, AVNU_MIDDLEWARE, EXTENDED_CONTRACT } from "../universal-adapters";
+import { PositionInfo } from "../universal-adapters";
+import { ERC20 } from "@/modules";
+import { SingleTokenInfo } from "../base-strategy";
+import { logger } from "@/utils";
+import { ExtendedAdapter } from "../universal-adapters";
+import { AvnuAdapter } from "../universal-adapters/avnu-adapter";
+import { MAX_LTV_BTC_USDC, TARGET_HF, USDC_TOKEN_DECIMALS } from "../vesu-extended-strategy/utils/constants";
+import { WBTC_TOKEN_DECIMALS } from "../vesu-extended-strategy/utils/constants";
+import { calculateBorrowAmountForStage1, calculateDecisiveFactorF, calculateVesuExposureExtraToDepositedCollateral } from "./utils/helper";
+import { Call } from "starknet";
+import { MINIMUM_EXTENDED_POSITION_SIZE } from "../vesu-extended-strategy/utils/constants";
+import { OrderSide } from "@/modules";
+import { _riskFactor, AUDIT_URL, calculateAmountDistributionForWithdrawalInWbtcStrategy, calculateExtendedLevergae, getFAQs, getInvestmentSteps } from "@/index.browser";
+import { Operations } from "./services/operationService";
+import { Protocols } from "@/interfaces";
+import { CommonAdapter, UnusedBalanceAdapter } from "../universal-adapters";
+import { calculateDebtAmountForMainatiningLtvOnVesu } from "./utils/helper"
+import { calculateVesuLeverage } from "../vesu-extended-strategy/utils/helper";
+
+export interface BtcFiVesuExtendedStrategySettings
+  extends UniversalStrategySettings {
+  underlyingToken: TokenInfo;
+  borrowable_assets: TokenInfo[];
+  targetHealthFactor: number;
+  quoteAmountToFetchPrice: Web3Number;
+  minHealthFactor: number;
+  aumOracle: ContractAddr;
+  minimumWBTCDifferenceForAvnuSwap: number;
+}
+
+export class BtcFiVesuExtendedStrategy<
+  S extends BtcFiVesuExtendedStrategySettings
+>
+  extends SVKStrategy<S>
+  implements Operations {
+  constructor(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<S>
+  ) {
+    super(config, pricer, metadata);
+    this.metadata.additionalInfo.adapters.forEach((adapter) => {
+      adapter.adapter.config.networkConfig = this.config;
+      adapter.adapter.config.pricer = this.pricer;
+      if ((adapter.adapter as VesuMultiplyAdapter).vesuAdapter) {
+        (adapter.adapter as VesuMultiplyAdapter).vesuAdapter.networkConfig =
+          this.config;
+        (adapter.adapter as VesuMultiplyAdapter).vesuAdapter.pricer =
+          this.pricer;
+      }
+    });
+  }
+
+  getTag() {
+    return `${BtcFiVesuExtendedStrategy.name}:${this.metadata.name}`;
+  }
+
+  async getAssetPrices() {
+    const wbtcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "WBTC"
+    )!;
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    )!;
+    const collateralPrice = await this.pricer.getPrice(wbtcToken.symbol);
+    const debtPrice = await this.pricer.getPrice(usdcToken.symbol);
+    return {
+      collateralPrice,
+      debtPrice,
+    };
+  }
+
+  async getUnusedBalanceUSDC(): Promise<SingleTokenInfo> {
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    )!;
+    const balance = await new ERC20(this.config).balanceOf(
+      usdcToken.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      usdcToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdcToken.symbol);
+    const usdValue =
+      Number(balance.toFixed(usdcToken.decimals)) * price.price;
+    return {
+      tokenInfo: usdcToken,
+      amount: balance,
+      usdValue,
+    };
+  }
+
+  async getVesuBorrowSupplyAdapter(): Promise<VesuBorrowSupplyAdapter | null> {
+    const vesuBorrowSupplyAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === VesuBorrowSupplyAdapter.name
+    );
+    if (!vesuBorrowSupplyAdapter) {
+      logger.error("vesu borrow supply adapter not found");
+      return null;
+    }
+    return vesuBorrowSupplyAdapter.adapter as VesuBorrowSupplyAdapter;
+  }
+
+  async getVesuAdapter(): Promise<VesuMultiplyAdapter | null> {
+    const vesuAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === VesuMultiplyAdapter.name
+    );
+    if (!vesuAdapter) {
+      logger.error("vesu adapter not found");
+      return null;
+    }
+    return vesuAdapter.adapter as VesuMultiplyAdapter;
+  }
+
+  async getAvnuAdapter(): Promise<AvnuAdapter | null> {
+    const avnuAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === AvnuAdapter.name
+    );
+    if (!avnuAdapter) {
+      logger.error("avnu adapter not found");
+      return null;
+    }
+    return avnuAdapter.adapter as AvnuAdapter;
+  }
+
+  async getExtendedAdapter(): Promise<ExtendedAdapter | null> {
+    const extendedAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === ExtendedAdapter.name
+    );
+    if (!extendedAdapter) {
+      logger.error("extended adapter not found");
+      return null;
+    }
+    return extendedAdapter.adapter as ExtendedAdapter;
+  }
+
+  async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<Call[]> {
+    try {
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
+      )!;
+      const approveCall = new ERC20(this.config).approve(
+        usdceToken.address,
+        this.metadata.additionalInfo.vaultAllocator,
+        amount
+      );
+      const transferCall = new ERC20(this.config).transfer(
+        usdceToken.address,
+        this.metadata.additionalInfo.vaultAllocator,
+        amount
+      );
+      const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
+        this.getMerkleTree()
+      );
+      const proofGroups = proofsInfo.proofs;
+      const call = this.getManageCall(
+        proofGroups,
+        await proofsInfo.callConstructor({ amount: amount })
+      );
+      return [approveCall, transferCall, call];
+    } catch (err) {
+      logger.error(`error moving assets to vault allocator: ${err}`);
+      return [];
+    }
+  }
+
+  async shouldInvest(): Promise<{
+    shouldInvest: boolean;
+    collateralPrice: number;
+    wbtcAmountForStage1: Web3Number;
+  } | null> {
+    try {
+      const vesuAdapter = await this.getVesuAdapter();
+      if (!vesuAdapter) {
+        logger.error(
+          `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return null;
+      }
+      logger.info(`${BtcFiVesuExtendedStrategy.name}::shouldInvest calling getUnusedBalance`);
+      const balance = await this.getUnusedBalance();
+      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+        logger.error(
+          `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
+        );
+        return {
+          shouldInvest: false,
+          collateralPrice: 0,
+          wbtcAmountForStage1: new Web3Number(0, 0),
+        };
+      }
+      const wbtcValueInUSD = new Web3Number(balance.usdValue.toFixed(2), 2);
+      const wbtcBalanceInWBTCUnits = new Web3Number(balance.amount.toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+      logger.info(`wbtcValueInUSD: ${wbtcValueInUSD}`);
+      // 95% of the total btc in vault allocator is invested
+      const amountToInvest = balance.amount;
+      //s.multipliedBy(AMOUNT_BUFFER_TO_KEEP_IN_INVESTING_CYCLE); right now full 100% of the btc in vault allocator is invested
+      logger.info(`amountToInvest: ${amountToInvest}`);
+      const {
+        collateralPrice,
+      } = await this.getAssetPrices();
+      /**
+       * If the amount is less than $10, then don't invest
+       */
+      const limitBalanceValue = new Web3Number(LIMIT_BALANCE_VALUE, 2);
+      if (amountToInvest.lessThan(limitBalanceValue.dividedBy(collateralPrice.price))) {
+        logger.info(`amountToInvest is less than limitBalanceValue, not investing`);
+        return null;
+      }
+      const assetsUnderVaultAllocator = await this.getAUM();
+      const assetsUnderVaultAllocatorInWBTCUnits = new Web3Number(assetsUnderVaultAllocator.net.amount.toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+      logger.info(`assetsUnderVaultAllocatorInWBTC: ${assetsUnderVaultAllocatorInWBTCUnits}`);
+      return {
+        shouldInvest: true,
+        collateralPrice: collateralPrice.price,
+        wbtcAmountForStage1: wbtcBalanceInWBTCUnits,
+      }
+    } catch (err) {
+      logger.error("error deciding invest", err);
+      return null
+    }
+  }
+
+  // boht the amounts are in USDC terms only
+  async shouldMoveAssets(vesuAmount: Web3Number, extendedAmount: Web3Number): Promise<Call[]> {
+    try {
+      const vesuAdapter = await this.getVesuAdapter();
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        logger.error(
+          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+        );
+        return [];
+      }
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return [];
+      }
+      const usdcAmountInWallet = (await this.getUnusedBalanceUSDC()).amount;
+      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+      logger.info(`usdcAmountInWallet: ${usdcAmountInWallet}`);
+      logger.info(`${BtcFiVesuExtendedStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForWithdrawal}, 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());
+      }
+
+      // 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
+      // Convert to Web3Number to maintain precision throughout calculations
+      const projectedExtendedBalance = new Web3Number(usdcAmountOnExtendedAvailableForWithdrawal, USDC_TOKEN_DECIMALS);
+
+      let adjustedProjectedBalance = projectedExtendedBalance;
+      if (extendedAmount.isNegative()) {
+        adjustedProjectedBalance = projectedExtendedBalance.minus(extendedAmount.abs());
+      }
+
+      const extendedAmountDifference = extendedTargetAmount.minus(adjustedProjectedBalance);
+      console.log("extendedAmountDifference", extendedAmountDifference)
+      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+      console.log("extendedAmountDifferenceAbs", extendedAmountDifferenceAbs)
+      // Track additional Extended movements
+      if (extendedAmountDifference.lessThan(0)) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+      } else if (extendedAmountDifference.greaterThan(0)) {
+        totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+      }
+
+      const vesuTargetAmount = vesuAmount.abs();
+      const projectedWalletBalance = usdcAmountInWallet
+        .plus(totalExtendedWithdrawal)
+        .minus(totalExtendedDeposit);
+
+      let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
+      const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
+
+      logger.info(`${BtcFiVesuExtendedStrategy.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[] = [];
+
+      // Handle negative extendedAmount (initial withdrawal needed)
+      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        try {
+          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+            {
+              to: Protocols.VAULT.name,
+              from: Protocols.EXTENDED.name,
+              amount: extendedAmount.abs(),
+            },
+            extendedAdapter,
+            vesuAdapter
+          );
+          if (extendedStatus) {
+            calls.push(...extendedCalls);
+          } else {
+            return [];
+          }
+        } catch (err) {
+          logger.error(`Failed moving assets to vault: ${err}`);
+        }
+      }
+
+      if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+        try {
+          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+            {
+              to: Protocols.EXTENDED.name,
+              from: Protocols.VESU.name,
+              amount: vesuAmount.abs(),
+            },
+            extendedAdapter,
+            vesuAdapter
+          );
+          calls.push(...vesuCalls);
+          if (!vesuStatus) {
+            return [];
+          }
+        } catch (err) {
+          logger.error(`Failed moving assets to vault: ${err}`);
+        }
+      }
+
+      // Handle Extended adjustments based on calculated difference
+      if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        if (extendedAmountDifference.greaterThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+              {
+                to: Protocols.EXTENDED.name,
+                from: Protocols.VAULT.name,
+                amount: extendedAmountDifference,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              calls.push(...extendedCalls);
+            } else {
+              logger.error(`Failed to move assets to extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets to extended: ${err}`);
+            return [];
+          }
+        } else if (extendedAmountDifference.lessThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: extendedAmountDifferenceAbs,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              calls.push(...extendedCalls);
+            } else {
+              logger.error(`Failed to withdraw from extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets from extended to vault: ${err}`);
+            return [];
+          }
+        }
+      }
+
+      // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
+      if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+        if (vesuAmountDifference.lessThanOrEqualTo(0)) {
+          logger.warn(
+            `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
+          );
+        } else {
+          // Move assets from Extended to Vault (which will then go to Vesu)
+          try {
+            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: vesuAmountDifference,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (!vesuStatus) {
+              logger.error(`Failed to move assets to vesu - operation returned false status`);
+              return [];
+            }
+            calls.push(...vesuCalls);
+          } catch (err) {
+            logger.error(`Failed moving assets to vault: ${err}`);
+            return [];
+          }
+        }
+      }
+      return calls;
+    } catch (err) {
+      logger.error(`Failed moving assets to vesu: ${err}`);
+      return [];
+    }
+  }
+
+  async moveAssetsFromVesuToVault(amountInWbtc: Web3Number, vesuBorrowSupplyAdapter: VesuBorrowSupplyAdapter, vesuMultiplyAdapter: VesuMultiplyAdapter): Promise<{
+    calls: Call[];
+    status: boolean;
+  }>{
+    try{
+     let calls: Call[] = [];
+     const aum = await this.getAUM();
+     logger.info(`aum: ${aum.net.amount}`);
+     const wbtcInVaultAllocator = await this.getUnusedBalance();
+     logger.info(`wbtcInVaultAllocator: ${wbtcInVaultAllocator}`);
+     const {
+      collateralTokenAmount,
+      debtTokenAmount
+     } = await vesuMultiplyAdapter.vesuAdapter.getAssetPrices();
+     logger.info(`collateralTokenAmount: ${collateralTokenAmount}`);
+     logger.info(`debtTokenAmount: ${debtTokenAmount}`);
+     const {
+      collateralPrice,
+      debtPrice
+     } = await this.getAssetPrices();
+     logger.info(`collateralPrice: ${collateralPrice}`);
+     logger.info(`debtPrice: ${debtPrice}`);
+     const vesuLeverage = calculateVesuLeverage()
+      const debtAmountToReduce = calculateDebtAmountForMainatiningLtvOnVesu(
+        debtTokenAmount.multipliedBy(-1),
+        collateralTokenAmount,
+        amountInWbtc.multipliedBy(-1).multipliedBy(vesuLeverage), // as the amount is being reduced from the position
+        collateralPrice.price,
+        debtPrice.price
+      )
+      if (!debtAmountToReduce) {
+        logger.error(`error calculating debt amount to reduce ${debtAmountToReduce} in moveAssetsFromVesuToVault`);
+        return {
+          calls: [],
+          status: false
+        };
+      }
+      logger.info(`debtAmountToReduce: ${debtAmountToReduce} in moveAssetsFromVesuToVault`);
+      const proofs = vesuBorrowSupplyAdapter.getProofsForMultiply(this.getMerkleTree());
+      const proofGroups = proofs.proofs;
+      const call = this.getManageCall(
+        proofGroups,
+        await proofs.callConstructor({
+          amount: amountInWbtc,
+          debtAmount: debtAmountToReduce,
+          isWithdraw: true,
+          closePosition: false
+        })
+      )
+     calls.push(call);
+     return {
+      calls: calls,
+      status: true
+     };
+    }catch(err){
+      logger.error(`error moving assets from vesu to vault: ${err}`);
+      return {
+        calls: [],
+        status: false
+      };
+    }
+  }
+
+  /**
+   * This function returns the calls used to move assets from one protocol to another
+   * @param params - The parameters for the move assets operation
+   * @param extendedAdapter - The extended adapter
+   * @param vesuAdapter - The vesu adapter
+   * @returns The calls to be made to the protocols
+   */
+  async moveAssets(params: {
+    from: string;
+    to: string;
+    amount: Web3Number;
+  }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<{
+    calls: Call[];
+    status: boolean;
+  }> {
+    try {
+      const avnuAdapter = await this.getAvnuAdapter();
+      const vesuSupplyBorrowAdapter = await this.getVesuBorrowSupplyAdapter();
+      if (!vesuSupplyBorrowAdapter) {
+        logger.error(`vesu supply borrow adapter not found: ${vesuSupplyBorrowAdapter}`);
+        return {
+          calls: [],
+          status: false
+        };
+      }
+      if (!avnuAdapter) {
+        logger.error(`avnu adapter not found: ${avnuAdapter}`);
+        return {
+          calls: [],
+          status: false
+        };
+      }
+      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
+      const {
+        collateralPrice,
+      } = await this.getAssetPrices();
+
+      if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VAULT.name) {
+        const proofsInfo = extendedAdapter.getProofs(
+          true,
+          this.getMerkleTree()
+        );
+        const calls = [];
+        const proofGroups = proofsInfo.proofs;
+        const call = this.getManageCall(
+          proofGroups,
+          await proofsInfo.callConstructor({ amount: params.amount })
+        );
+        calls.push(call);
+        return {
+          calls: [call],
+          status: true
+        };
+      } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
+        const extendedLeverage = calculateExtendedLevergae();
+        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        if (!extendedHoldings) {
+          logger.error(`error getting extended holdings: ${extendedHoldings}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        const extendedHoldingAmount = new Web3Number(
+          extendedHoldings.availableForWithdrawal,
+          USDC_TOKEN_DECIMALS
+        );
+        logger.info(`${BtcFiVesuExtendedStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+        if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
+          const leftAmountAfterWithdrawalAmountInAccount = params.amount.abs().minus(extendedHoldingAmount);
+          logger.info(`${BtcFiVesuExtendedStrategy.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
+          )
+          if (!openLongPosition) {
+            logger.error(`error opening long position: ${openLongPosition}`);
+            return {
+              calls: [],
+              status: false
+            };
+          }
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+        const withdrawalFromExtended =
+          await extendedAdapter.withdrawFromExtended(params.amount);
+        if (withdrawalFromExtended) {
+          /**
+          * We need to move assets from my wallet back to vault contract
+          */
+          const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`);
+          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          if (calls.length > 0) {
+            return {
+              calls: calls,
+              status: true
+            };
+          }
+        } else {
+          logger.error("withdrawal from extended failed");
+          return {
+            calls: [],
+            status: false
+          };
+        }
+      } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
+        //withdraw from vesu 
+        /**
+         * Amount for this movement is in wbtc terms only
+         */
+        let calls: Call[] = [];
+        const {
+          calls:vesuWithdrawalCalls,
+          status:vesuWithdrawalStatus
+        } = await this.moveAssetsFromVesuToVault(
+          params.amount,
+          vesuSupplyBorrowAdapter,
+          vesuAdapter
+        )
+        if (!vesuWithdrawalStatus) {
+          logger.error("error withdrawing from vesu");
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        calls.push(...vesuWithdrawalCalls);
+        return {
+          calls: calls,
+          status: true
+        };
+      }
+      return {
+        calls: [],
+        status: false
+      };
+    } catch (err) {
+      logger.error(`error moving assets: ${err}`);
+      return {
+        calls: [],
+        status: false
+      };
+    }
+  }
+
+
+  /**
+   * amountInWbtc is the amount of wbtc tokens on vault allocator deposited by the user, to be used as collateral for borrowing usdc from vesu
+   * This function is used to first lend wbtc and then borrow usdc from vesu
+   * @returns { extendedAmountInBTC: Web3Number; calls: Call[]; }
+   * extendedAmountInBTC: The amount of BTC that is needed to be deposited to the extended contract
+   * calls: The calls to be made to the extended contract
+   */
+  async handleLendingBorrowingForStage1(amountInWBTC: Web3Number): Promise<{
+    calls: Call[];
+    debtTaken: Web3Number;
+  }> {
+    try {
+      const vesuBorrowSupplyAdapter = await this.getVesuBorrowSupplyAdapter();
+      if (!vesuBorrowSupplyAdapter) {
+        logger.error("vesu borrow supply adapter not found");
+        return {
+          calls: [],
+          debtTaken: new Web3Number(0, USDC_TOKEN_DECIMALS)
+        }
+      }
+      const supplyToken = vesuBorrowSupplyAdapter.config.supplyToken;
+      const borrowToken = vesuBorrowSupplyAdapter.config.borrowToken;
+      let calls: Call[] = [];
+      if (!vesuBorrowSupplyAdapter) {
+        logger.error("vesu borrow supply adapter not found");
+        return {
+          calls: [],
+          debtTaken: new Web3Number(0, USDC_TOKEN_DECIMALS)
+        }
+      }
+      const collateralPrice = await vesuBorrowSupplyAdapter.config.pricer?.getPrice(
+        supplyToken.symbol
+      );
+      const debtPrice = await vesuBorrowSupplyAdapter.config.pricer?.getPrice(borrowToken.symbol);
+      const existingPosition = await vesuBorrowSupplyAdapter.vesuAdapter.getPositions(
+        vesuBorrowSupplyAdapter.config.networkConfig
+      );
+      const existingCollateralAmount = existingPosition[0].amount;
+      /**
+       * Aum is the assets under vault allocator in wbtc, when user adds lets say 0.5 btc then that also is already counted inside this aum
+       */
+      const additionalCollateralForLendingBorrowing = amountInWBTC;
+      const assetsUnderVaultAllocator = await this.getAUM();
+      const vesuCollateralAmountWithoutMultiplier = new Web3Number(existingCollateralAmount.minus(assetsUnderVaultAllocator.net.amount).plus(amountInWBTC).toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+      logger.info(`vesuCollateralAmountWithoutMultiplier :: ${vesuCollateralAmountWithoutMultiplier}`);
+
+      const debtAmountStage1 = calculateBorrowAmountForStage1(
+        TARGET_HF, // not the target health factor, but the percentage of collateral we borrow back
+        MAX_LTV_BTC_USDC,
+        vesuCollateralAmountWithoutMultiplier, // WBTC terms, keep original decimals
+        additionalCollateralForLendingBorrowing, // WBTC terms, keep original decimals
+        collateralPrice.price,
+        debtPrice.price
+      );
+      logger.info(`debtAmountStage1: ${debtAmountStage1}`);
+      if (debtAmountStage1?.eq(0) || !debtAmountStage1) {
+        logger.info(`${BtcFiVesuExtendedStrategy.name}::handleLendingBorrowingForStage1 debt amount is 0, not lending or borrowing`);
+        return {
+          calls: [],
+          debtTaken: new Web3Number(0, USDC_TOKEN_DECIMALS)
+        }
+      }
+      if (debtAmountStage1.lessThan(0)) {
+        const proofs = vesuBorrowSupplyAdapter.getProofsForDebtPayment(this.getMerkleTree());
+        const debtToPay = debtAmountStage1.abs();
+        const proofGroups = proofs.proofs;
+        const call = this.getManageCall(
+          proofGroups,
+          await proofs.callConstructor({
+            debtAmount: debtToPay,
+            supplyAmount: new Web3Number(0, WBTC_TOKEN_DECIMALS)
+          })
+        );
+        calls.push(call);
+        return {
+          calls: calls as Call[],
+          debtTaken: debtAmountStage1
+        }
+      }
+      logger.info(`The amount of debt is positive, ${debtAmountStage1}`);
+      const proofs = vesuBorrowSupplyAdapter.getProofsForBorrowing(this.getMerkleTree());
+      const proofGroups = proofs.proofs;
+      const call = this.getManageCall(
+        proofGroups, 
+        await proofs.callConstructor({
+          supplyAmount: amountInWBTC,
+          debtAmount: debtAmountStage1
+        })   
+      );
+      calls.push(call);
+      logger.info(`calls: ${calls}`);
+      return {
+        calls: calls as Call[],
+        debtTaken: debtAmountStage1
+      }
+    } catch (err) {
+      logger.error(`error handling lending borrowing for stage 1: ${err}`);
+      return {
+        calls: [],
+        debtTaken: new Web3Number(0, USDC_TOKEN_DECIMALS)
+      }
+    }
+  }
+
+  /**
+   * This function is used to withdraw the assets from the vault positions to the vault allocator
+   * @param amount is the amount of wbtc to be arranged
+   * @returns { calls: Call[]; status: boolean; }
+   * calls: The calls to be made to the avnu contract
+   * status: The status of the withdrawal
+   */
+  async handleWithdraw(amount: Web3Number): Promise<{
+    calls: Call[];
+    status: boolean;
+  }> {
+    try {
+      let calls: Call[] = [];
+      let status: boolean = true;
+      const wbtcAmountInVaultAllocator = await this.getUnusedBalance();
+      const wbtcAmountDifference = amount.minus(wbtcAmountInVaultAllocator.amount);
+      if (wbtcAmountDifference.lessThan(0)) {
+        const withdrawCall = await this.getBringLiquidityCall({ amount: amount });
+        calls.push(withdrawCall);
+        return {
+          calls: calls,
+          status: true
+        }
+      }
+      const vesuAdapter = await this.getVesuAdapter();
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        status = false;
+        logger.error(
+          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+        );
+        return {
+          calls: calls,
+          status: status
+        };
+      }
+      const { collateralTokenAmount } =
+        await vesuAdapter.vesuAdapter.getAssetPrices();
+      const aum = await this.getAUM();
+      const assetsUnderVaultAllocatorInWBTC = aum.net.amount;
+      const {
+        collateralPrice,
+      } = await this.getAssetPrices();
+      const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        status = false;
+        logger.error("error getting extended position", extendedPositon);
+        return {
+          calls: calls,
+          status: status
+        }
+      }
+      const vesuExposureInMultiplier = calculateVesuExposureExtraToDepositedCollateral(
+        assetsUnderVaultAllocatorInWBTC,
+        wbtcAmountInVaultAllocator.amount,
+        collateralTokenAmount
+      )
+      if (!vesuExposureInMultiplier) {
+        status = false;
+        logger.error("error calculating vesu exposure in multiplier");
+        return {
+          calls: calls,
+          status: status
+        }
+      }
+      const amountDistributionForWithdrawal = calculateAmountDistributionForWithdrawalInWbtcStrategy(
+        amount,
+        vesuExposureInMultiplier,
+        extendedPositon
+      )
+      if (!amountDistributionForWithdrawal) {
+        status = false;
+        logger.error("error calculating amount distribution for withdrawal");
+        return {
+          calls: calls,
+          status: status
+        }
+      }
+      const {
+        vesuAmount,
+        extendedAmount
+      } = amountDistributionForWithdrawal;
+
+      if (status && vesuAmount.greaterThan(0)) {
+        /**
+         * Vesu amount is in wbtc terms only
+         */
+        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+          {
+            amount: vesuAmount,
+            from: Protocols.VESU.name,
+            to: Protocols.VAULT.name,
+          },
+          extendedAdapter,
+          vesuAdapter
+        );
+        status = vesuStatus;
+        calls.push(...vesuCalls);
+      }
+      if (status && extendedAmount.greaterThan(0)) {
+        const extendedAmountInUsdc = new Web3Number(extendedAmount.multipliedBy(collateralPrice.price).toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+          {
+            amount: extendedAmountInUsdc,
+            from: Protocols.EXTENDED.name,
+            to: Protocols.VAULT.name,
+          },
+          extendedAdapter,
+          vesuAdapter
+        );
+        status = extendedStatus;
+        if (status) {
+          calls.push(...extendedCalls);
+        } else {
+          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
+          return {
+            calls: [],
+            status: status
+          };
+        }
+      }
+      const withdrawCall = await this.getBringLiquidityCall({
+        amount: amount
+      })
+      logger.info("withdraw call", withdrawCall);
+      calls.push(withdrawCall);
+      return {
+        calls: calls,
+        status: true
+      }
+    } catch (err) {
+      logger.error(`error handling withdraw: ${err}`);
+      return {
+        calls: [],
+        status: false
+      }
+    }
+  }
+
+  /**
+   * This function is used to handle the stage 2 positions, that is opening leveraged positions on extended and vesu
+   * @returns { decisiveFactor: Web3Number; vesuAmountInUSDC: Web3Number; extendedAmountInUSDC: Web3Number; }
+   * decisiveFactor: The decisive factor for the stage 2 positions
+   * vesuAmountInUSDC: The amount of usdc to be invested in vesu
+   * extendedAmountInUSDC: The amount of usdc to be invested in extended
+   */
+  async handleStage2Positions(): Promise<{
+    decisiveFactor: Web3Number;
+    vesuAmountInUSDC: Web3Number;
+    extendedAmountInUSDC: Web3Number;
+  }> {
+    try {
+      const extendedAdapter = await this.getExtendedAdapter();
+      let decisiveFactor = new Web3Number(0, 3);
+      let vesuAmountInUSDC = new Web3Number(0, USDC_TOKEN_DECIMALS);
+      let extendedAmountInUSDC = new Web3Number(0, USDC_TOKEN_DECIMALS);
+      if (!extendedAdapter) {
+        logger.error("extended adapter not found");
+        return {
+          decisiveFactor,
+          vesuAmountInUSDC,
+          extendedAmountInUSDC
+        }
+      }
+      const extendedPosition = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPosition) {
+        logger.error("error getting extended position");
+        return {
+          decisiveFactor,
+          vesuAmountInUSDC,
+          extendedAmountInUSDC
+        }
+      }
+      const extendedExposureWBTC = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].size || 0, WBTC_TOKEN_DECIMALS) : new Web3Number(0, WBTC_TOKEN_DECIMALS);
+      const vesuAdapter = await this.getVesuAdapter();
+      if (!vesuAdapter) {
+        logger.error("vesu adapter not found");
+        return {
+          decisiveFactor,
+          vesuAmountInUSDC,
+          extendedAmountInUSDC
+        }
+      }
+      let {
+        collateralPrice,
+        debtPrice
+      } = await vesuAdapter.vesuAdapter.getAssetPrices();
+      if (!collateralPrice || !debtPrice) {
+        logger.error("error getting collateral price or debt price");
+        return {
+          decisiveFactor,
+          vesuAmountInUSDC,
+          extendedAmountInUSDC
+        }
+      }
+      /**
+       * Making sure debt price is positive, 
+       */
+      const debtPriceInUsdc = new Web3Number(debtPrice.price, USDC_TOKEN_DECIMALS).abs();
+      const vesuPosition = await vesuAdapter.vesuAdapter.getPositions(vesuAdapter.config.networkConfig);
+      const vesuCollateralAmount = vesuPosition[0].amount;
+      logger.info(`vesuCollateralAmount: ${vesuCollateralAmount}`);
+      const vesuDebtAmount = vesuPosition[1].amount.abs();
+      logger.info(`vesuDebtAmount: ${vesuDebtAmount}`);
+      const unusedBalanceUSDC = await this.getUnusedBalanceUSDC();
+      logger.info(`unusedBalanceUSDC: ${unusedBalanceUSDC}`);
+      const unusedBalanceUSDCe = (await extendedAdapter.getExtendedDepositAmount())?.availableForWithdrawal || new Web3Number(0, USDC_TOKEN_DECIMALS);
+      const totalBalanceUSDC = unusedBalanceUSDC.amount.plus(unusedBalanceUSDCe);
+      const wbtcBalance = await this.getUnusedBalance();
+      const assetsUnderVaultAllocator = await this.getAUM();
+      const assetsUnderVaultAllocatorInWBTC = new Web3Number(assetsUnderVaultAllocator.net.amount.toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+      const decisiveFactorF = calculateDecisiveFactorF(
+        extendedExposureWBTC,
+        assetsUnderVaultAllocatorInWBTC,
+        wbtcBalance.amount,
+        vesuCollateralAmount,
+        totalBalanceUSDC,
+        vesuDebtAmount,
+        collateralPrice.price,
+        debtPriceInUsdc.toNumber(),
+      )
+
+      if (!decisiveFactorF) {
+        logger.error("error calculating decisive factor f");
+        return {
+          decisiveFactor,
+          vesuAmountInUSDC,
+          extendedAmountInUSDC
+        }
+      }
+      decisiveFactor = decisiveFactorF;
+      vesuAmountInUSDC = new Web3Number(decisiveFactor.multipliedBy(totalBalanceUSDC.toWei()).toFixed(0), 0);
+      extendedAmountInUSDC = new Web3Number(totalBalanceUSDC.toWei(), 0).minus(vesuAmountInUSDC);
+      logger.info(`vesuAmountInUSDC: ${vesuAmountInUSDC}`);
+      logger.info(`extendedAmountInUSDC: ${extendedAmountInUSDC}`);
+      logger.info(`decisiveFactor: ${decisiveFactor}`);
+      return {
+        decisiveFactor,
+        vesuAmountInUSDC: vesuAmountInUSDC.dividedBy(10 ** USDC_TOKEN_DECIMALS),
+        extendedAmountInUSDC: extendedAmountInUSDC.dividedBy(10 ** USDC_TOKEN_DECIMALS)
+      }
+    } catch (err) {
+      logger.error("error handling stage 2 positions", err);
+      return {
+        decisiveFactor: new Web3Number(0, 3),
+        vesuAmountInUSDC: new Web3Number(0, USDC_TOKEN_DECIMALS),
+        extendedAmountInUSDC: new Web3Number(0, USDC_TOKEN_DECIMALS)
+      }
+    }
+  }
+
+  /**
+   * This function is used to check the price difference between avnu and extended
+   * @param extendedAdapter - The extended adapter
+   * @param vesuAdapter - The vesu adapter
+   * @param avnuAdapter - The avnu adapter
+   * @param positionType - The position type
+   * @returns { boolean } - The result of the check
+   * true if the price difference is greater than the minimum price difference for swap opening
+   * false if the price difference is less than the minimum price difference for swap opening
+   */
+  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());
+
+    if (!btcPriceAvnu) {
+      logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
+      return false;
+    }
+    logger.info(`price: ${price}`);
+    logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
+    const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+    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(`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(`result: ${result}`);
+      return result;
+    }
+  }
+
+  async getAUM(): Promise<{ net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[] }> {
+    const allPositions: PositionInfo[] = [];
+    const wbtcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === this.asset().symbol
+    )!;
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    )!;
+
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+      /**
+       * Make sure that the position from supplyLend adapter doesnt recount the positon from multiply adapter
+       */
+      if (adapter.id !== `${VesuBorrowSupplyAdapter.name}_${wbtcToken.symbol}_${usdcToken.symbol}`) {
+        const positions = await adapter.adapter.getPositions();
+        allPositions.push(...positions);
+      }
+    }
+    const assetPrice = await this.pricer.getPrice(this.asset().symbol);
+    let netAUM = new Web3Number(0, this.asset().decimals);
+    for (let position of allPositions) {
+      if (position.tokenInfo.address.eq(this.asset().address)) {
+        netAUM = netAUM.plus(position.amount);
+      } else {
+        netAUM = netAUM.plus(position.usdValue / assetPrice.price);
+      }
+    }
+
+    const prevAum = await this.getPrevAUM();
+    const realAUM: PositionInfo = {
+      tokenInfo: this.asset(),
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * assetPrice.price,
+      apy: { apy: netAUM.toNumber() * assetPrice.price, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.NONE // just placeholder
+    };
+
+    const estimatedAUMDelta: PositionInfo = {
+      tokenInfo: this.asset(),
+      amount: Web3Number.fromWei('0', this.asset().decimals),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      remarks: AUMTypes.DEFISPRING,
+      protocol: Protocols.NONE // just placeholder
+    };
+
+    return {
+      net: {
+        tokenInfo: this.asset(),
+        amount: netAUM,
+        usdValue: netAUM.toNumber() * assetPrice.price
+      }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]
+    };
+  }
+
+  async getFundingRateHistory(startDate: Date, endDate: Date, page: number) {
+    try {
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!extendedAdapter) {
+        logger.error("extended adapter not found");
+        return [];
+      }
+      const fundingRateHistory = await extendedAdapter.client.getFundingRates("BTC-USD", "LONG", {
+        startTime: startDate.toISOString(),
+        endTime: endDate.toISOString(),
+        page: page
+      });
+      return fundingRateHistory;
+    } catch (error) {
+      console.error("error getting funding rate history", error);
+      return [];
+    }
+  }
+
+  async getVesuExposureWithoutUserDepositedCollateral(): Promise<Web3Number> {
+    try {
+      const extendedAdapter = await this.getExtendedAdapter();
+      const vesuAdapter = await this.getVesuAdapter();
+      if (!extendedAdapter || !vesuAdapter) {
+        logger.error("extended adapter or vesu adapter not found");
+        return new Web3Number(0, USDC_TOKEN_DECIMALS);
+      }
+      const balance = await this.getUnusedBalance();
+      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+        logger.error(
+          `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
+        );
+        return new Web3Number(0, USDC_TOKEN_DECIMALS);
+      }
+      const amountToInvest = balance.amount;
+      const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        logger.error("error getting extended position to decide move assets");
+        return new Web3Number(0, USDC_TOKEN_DECIMALS)
+      }
+      const { collateralTokenAmount } =
+        await vesuAdapter.vesuAdapter.getAssetPrices();
+      const assetsUnderVaultAllocator = await this.getAUM();
+      const assetsUnderVaultAllocatorInWBTC = new Web3Number(assetsUnderVaultAllocator.net.amount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      logger.info(`assetsUnderVaultAllocatorInWBTC: ${assetsUnderVaultAllocatorInWBTC}`);
+      const addedCollateralNet = new Web3Number(amountToInvest.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      logger.info(`addedCollateralNet: ${addedCollateralNet}`);
+      const collateralExposureVesuInMultiplier = calculateVesuExposureExtraToDepositedCollateral(
+        assetsUnderVaultAllocatorInWBTC,
+        addedCollateralNet,
+        collateralTokenAmount
+      );
+      if (collateralExposureVesuInMultiplier === null) {
+        logger.error("error calculating collateral exposure vesu in multiplier");
+        return new Web3Number(0, USDC_TOKEN_DECIMALS);
+      }
+      return collateralExposureVesuInMultiplier;
+    } catch (err) {
+      logger.error("error getting vesu exposure without user deposits", err);
+      return new Web3Number(0, USDC_TOKEN_DECIMALS);
+    }
+  }
+
+  async getExtendedPositionExposure(): Promise<Web3Number> {
+    try {
+      const extendedAdapter = await this.getExtendedAdapter();
+      if (!extendedAdapter) {
+        logger.error("extended adapter not found");
+        return new Web3Number(0, USDC_TOKEN_DECIMALS);
+      }
+      const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        logger.error("error getting extended position to decide move assets");
+        return new Web3Number(0, USDC_TOKEN_DECIMALS)
+      }
+      const extendedExposureWBTC = extendedPositon.length > 0 ? new Web3Number(extendedPositon[0].size || 0, WBTC_TOKEN_DECIMALS) : new Web3Number(0, WBTC_TOKEN_DECIMALS);
+      return extendedExposureWBTC;
+    } catch (err) {
+      logger.error("error getting extended position exposure", err);
+      return new Web3Number(0, USDC_TOKEN_DECIMALS)
+    }
+  }
+
+  async getBringLiquidityCall(params: { amount: Web3Number; }): Promise<Call> {
+    const { amount } = params;
+    const avnuAdapter = await this.getAvnuAdapter();
+    if (!avnuAdapter) {
+      logger.error("avnu adapter not found");
+      return {} as Call;
+    }
+    const usdcToWbtcProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
+    const callUsdcToWbtc = this.getManageCall(
+      usdcToWbtcProofsInfo.proofs,
+      await usdcToWbtcProofsInfo.callConstructor({ amount: amount })
+    );
+    return callUsdcToWbtc;
+  }
+}
+
+
+function getLooperSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  vaultSettings: BtcFiVesuExtendedStrategySettings,
+  pool1: ContractAddr,
+  extendedBackendUrl: string,
+  extendedApiKey: string,
+  vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number,
+) {
+  vaultSettings.leafAdapters = [];
+
+  const wbtcToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === underlyingSymbol
+  )!;
+  const usdcToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol
+  )!;
+
+  const baseAdapterConfig: BaseAdapterConfig = {
+    baseToken: wbtcToken,
+    supportedPositions: [
+      { asset: usdcToken, isDebt: true },
+      { asset: wbtcToken, isDebt: false },
+    ],
+    //Since we open 2 positions, we need to add both positions, one is debt another is collateral
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
+    vaultAllocator: vaultSettings.vaultAllocator,
+    vaultAddress: vaultSettings.vaultAddress,
+  };
+
+  const avnuAdapter = new AvnuAdapter({
+    ...baseAdapterConfig,
+    avnuContract: AVNU_MIDDLEWARE,
+    slippage: 0.001,
+    baseUrl: AVNU_QUOTE_URL,
+    minimumExtendedPriceDifferenceForSwapOpen: minimumExtendedPriceDifferenceForSwapOpen,
+    maximumExtendedPriceDifferenceForSwapClosing: maximumExtendedPriceDifferenceForSwapClosing,
+  });
+  const extendedAdapter = new ExtendedAdapter({
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: usdcToken, isDebt: true },
+    ],
+    vaultIdExtended: vaultIdExtended,
+    extendedContract: EXTENDED_CONTRACT,
+    extendedBackendUrl: extendedBackendUrl,
+    extendedApiKey: extendedApiKey,
+    extendedTimeout: 30000,
+    extendedRetries: 3,
+    extendedBaseUrl: "https://api.starknet.extended.exchange",
+    extendedMarketName: "BTC-USD",
+    extendedPrecision: 5,
+    avnuAdapter: avnuAdapter,
+    minimumExtendedMovementAmount: minimumExtendedMovementAmount,
+    retryDelayForOrderStatus: minimumExtendedRetriesDelayForOrderStatus,
+  });
+
+  const vesuMultiplyAdapter = new VesuMultiplyAdapter({
+    poolId: pool1,
+    collateral: wbtcToken,
+    debt: usdcToken,
+    targetHealthFactor: vaultSettings.targetHealthFactor,
+    minHealthFactor: vaultSettings.minHealthFactor,
+    quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: wbtcToken, isDebt: false },
+      { asset: usdcToken, isDebt: true },
+    ],
+    minimumVesuMovementAmount: minimumVesuMovementAmount,
+  });
+
+  const vesuSupplyBorrowAdapter = new VesuBorrowSupplyAdapter({
+    poolId: pool1,
+    supplyToken: wbtcToken,
+    borrowToken: usdcToken,
+    targetHealthFactor: vaultSettings.targetHealthFactor,
+    minHealthFactor: vaultSettings.minHealthFactor,
+    quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: wbtcToken, isDebt: false },
+      { asset: usdcToken, isDebt: true },
+    ],
+    vaultIdExtended: vaultIdExtended,
+    extendedContract: EXTENDED_CONTRACT,
+    extendedBackendUrl: extendedBackendUrl,
+    extendedApiKey: extendedApiKey,
+    extendedTimeout: 30000,
+    extendedRetries: 3,
+    extendedBaseUrl: "https://api.starknet.extended.exchange",
+    extendedMarketName: "BTC-USD",
+    extendedPrecision: 5,
+    extendedAdapter: extendedAdapter,
+    avnuAdapter: avnuAdapter,
+    minimumExtendedMovementAmount: minimumExtendedMovementAmount,
+    retryDelayForOrderStatus: minimumExtendedRetriesDelayForOrderStatus,
+  })
+
+  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+    ...baseAdapterConfig,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${vesuMultiplyAdapter.name}_${wbtcToken.symbol}_${usdcToken.symbol}`,
+    adapter: vesuMultiplyAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${vesuSupplyBorrowAdapter.name}_${wbtcToken.symbol}_${usdcToken.symbol}`,
+    adapter: vesuSupplyBorrowAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${unusedBalanceAdapter.name}_${wbtcToken.symbol}`,
+    adapter: unusedBalanceAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${extendedAdapter.name}_${wbtcToken.symbol}`,
+    adapter: extendedAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${avnuAdapter.name}_${wbtcToken.symbol}`,
+    adapter: avnuAdapter,
+  });
+
+  const commonAdapter = new CommonAdapter({
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    manager: vaultSettings.manager,
+    asset: wbtcToken.address,
+  });
+
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() =>
+    vesuMultiplyAdapter.getWithdrawLeaf()
+  );
+  vaultSettings.leafAdapters.push(() => vesuSupplyBorrowAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuSupplyBorrowAdapter.getBorrowLeaf());
+  vaultSettings.leafAdapters.push(() => vesuSupplyBorrowAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => vesuSupplyBorrowAdapter.getPayDebtLeaf());
+  vaultSettings.leafAdapters.push(() => vesuSupplyBorrowAdapter.getMultiplyLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+  // Doubt here, should this be usdcToken.address, or wbtcToken.address?
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        wbtcToken.address,
+        vaultSettings.vaultAddress,
+        UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY
+      )
+      .bind(commonAdapter)
+  );
+
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
+      .bind(commonAdapter)
+  );
+  return vaultSettings;
+}
+
+function getDescription(tokenSymbol: string, underlyingSymbol: string) {
+  return VaultDescription(tokenSymbol, underlyingSymbol);
+}
+
+export default function VaultDescription(
+  lstSymbol: string,
+  underlyingSymbol: string
+) {
+  const containerStyle = {
+    maxWidth: "800px",
+    margin: "0 auto",
+    backgroundColor: "#111",
+    color: "#eee",
+    fontFamily: "Arial, sans-serif",
+    borderRadius: "12px",
+  };
+
+  return (
+    <div style={containerStyle}>
+      <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.
+      </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.
+      </p>
+
+      <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.
+        </p>
+      </div>
+      <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.
+        </p>
+      </div>
+      {/* <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+        <p style={{ fontSize: "13px", color: "#ccc" }}>
+          <strong>APY assumptions:</strong> APY shown is the max possible value given current LST and borrowing rates. True APY will be subject to the actual leverage, based on above point. More insights on exact APY will be added soon.
+        </p>
+      </div> */}
+    </div>
+  );
+}
+
+
+const re7UsdcPrimeDevansh: BtcFiVesuExtendedStrategySettings = {
+  vaultAddress: ContractAddr.from("0x51c668b4c64f94d4dcfe9f5a9c6a8994fa520e5dfed966e7fdc8b42cbf2832"),
+  manager: ContractAddr.from("0x4af6fb4245d7078c941cbbddf2f76cb201732317bd640c092370578e1799d76"),
+  vaultAllocator: ContractAddr.from("0x74313caaf10f7bc60269be922f49b64390cf2540639dfb53a209220df2f29aa"),
+  redeemRequestNFT: ContractAddr.from("0xa2b972b7edffed6960c74f3a57942fdf8d92180ccd076b523e167cb612b53c"),
+  aumOracle: ContractAddr.from("0x6ff943c5ba828be6abf9d70e4d3275ff3d9d3e7aade9ec9e90898e4850a26f8"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.4,
+  minHealthFactor: 1.05,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "WBTC"
+  )!,
+  quoteAmountToFetchPrice: new Web3Number(
+    "100",
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")!.decimals
+  ),
+  borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "USDC")!],
+  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+}
+
+export const BtcFiVesuExtendedTestStrategies = (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<BtcFiVesuExtendedStrategySettings>[] => {
+  return [
+    getStrategySettingsVesuExtendedBTCFi('USDC', 'WBTC', re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
+  ]
+}
+
+
+function getStrategySettingsVesuExtendedBTCFi(lstSymbol: string, underlyingSymbol: string, addresses: BtcFiVesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<BtcFiVesuExtendedStrategySettings> {
+  return {
+    name: `Extended BTCfi ${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.Re7USDCCore, extendedBackendUrl, extendedApiKey, 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)
+    },
+    auditUrl: AUDIT_URL,
+    protocols: [Protocols.EXTENDED, Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 18),
+    contractDetails: getContractDetails(addresses),
+    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.'
+  }
+}
+
+
+
+// const oldContracts ={
+//   vaultAddress: ContractAddr.from("0x5f9e7967b8ebbf0e19979974895a1e580d51328bcc7ae786c369aa584e5df62"),
+//   manager: ContractAddr.from("0x12e2df5f7c30a2a2c852a77fa20873d21ee5a18855832693daba5b92284cb98"),
+//   vaultAllocator: ContractAddr.from("0xdb3e372e39e94c7f30f9d6246ee3a71b701b5ad4e764d4c35f23b3035d221b"),
+//   redeemRequestNFT: ContractAddr.from("0x48f83a32897a894c8ed3a1821dc2074e489d9cc1422600ac2fdf6861b0a85b3"),
+//   aumOracle: ContractAddr.from("0x4833ebd242fed526f1603fdc98d8faf62d20cadf33297d81670c8f015dd0b0b"),
+// }