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

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

@@ -0,0 +1,1420 @@
+import {
+  getMainnetConfig,
+  IConfig,
+  IStrategyMetadata,
+  TokenInfo,
+} from "@/interfaces";
+import {
+  UNIVERSAL_MANAGE_IDS,
+  UniversalStrategySettings,
+} from "../universal-strategy";
+import { 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, EXTENDED_QTY_PRECISION, LIMIT_BALANCE, LIMIT_BALANCE_VALUE, MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WALLET_ADDRESS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
+import { PricerBase } from "@/modules/pricerBase";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Global } from "@/global";
+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 { getContractDetails } from "../universal-strategy";
+import { highlightTextWithLinks } from "@/interfaces";
+import { PositionInfo } from "../universal-adapters";
+import { APYType } from "../universal-adapters";
+import { AUMTypes } from "../universal-strategy";
+import { VesuPools } from "../universal-adapters";
+import {
+  BaseAdapterConfig,
+  CommonAdapter,
+  UnusedBalanceAdapter,
+  VesuMultiplyAdapter,
+} from "../universal-adapters";
+import { Operations } from "./services/operationService";
+import {
+  AVNU_EXCHANGE,
+  AVNU_QUOTE_URL,
+  AVNU_MIDDLEWARE,
+  EXTENDED_CONTRACT,
+} from "../universal-adapters/adapter-utils";
+import { PricerFromApi } from "@/modules";
+import { ExtendedAdapter } from "../universal-adapters/extended-adapter";
+import { SVKStrategy } from "../svk-strategy";
+import { AvnuAdapter } from "../universal-adapters/avnu-adapter";
+import {
+  calculateAmountDistribution,
+  calculateAmountDistributionForWithdrawal,
+  calculateVesuLeverage,
+  calculateVesUPositionSizeGivenExtended
+} from "./utils/helper";
+import { SingleTokenInfo } from "../base-strategy";
+import { Call } from "starknet";
+import { PositionTypeAvnuExtended} from "../universal-strategy";
+
+
+export interface VesuExtendedStrategySettings
+  extends UniversalStrategySettings {
+  underlyingToken: TokenInfo;
+  borrowable_assets: TokenInfo[];
+  targetHealthFactor: number;
+  quoteAmountToFetchPrice: Web3Number;
+  minHealthFactor: number;
+  aumOracle: ContractAddr;
+  minimumWBTCDifferenceForAvnuSwap: number;
+}
+
+export class VesuExtendedMultiplierStrategy<
+  S extends VesuExtendedStrategySettings
+>
+  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 `${VesuExtendedMultiplierStrategy.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 getUnusedBalanceUSDCE(): Promise<SingleTokenInfo> {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    )!;
+    const balance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      WALLET_ADDRESS,
+      usdceToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const usdValue =
+      Number(balance.toFixed(usdceToken.decimals)) * price.price;
+    return {
+      tokenInfo: usdceToken,
+      amount: balance,
+      usdValue,
+    };
+  }
+
+
+  async getUnusedBalanceWBTC(): Promise<SingleTokenInfo> {
+    const collateralToken = this.metadata.additionalInfo.borrowable_assets[0]!;
+    const balance = await new ERC20(this.config).balanceOf(
+      collateralToken.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      collateralToken.decimals
+    );
+    const price = await this.pricer.getPrice(collateralToken.symbol);
+    const usdValue =
+      Number(balance.toFixed(collateralToken.decimals)) * price.price;
+    return {
+      tokenInfo: collateralToken,
+      amount: balance,
+      usdValue,
+    };
+  }
+
+  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;
+    vesuAmount: Web3Number;
+    extendedAmount: Web3Number;
+    extendedLeverage: number;
+    collateralPrice: number;
+    debtPrice: number;
+    vesuLeverage: number;
+  }> {
+    try {
+      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}`);
+      
+      if (!vesuAdapter) {
+        logger.error(
+          `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter) {
+        logger.error(
+          `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter.client) {
+        logger.error(
+          `Extended adapter client not initialized. This may be a temporary initialization failure - check network connectivity and API availability.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      
+      logger.info(`${VesuExtendedMultiplierStrategy.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,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      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) {
+          logger.error(
+            `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 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 amountToInvestNumber = amountToInvest.toNumber();
+      if (!Number.isFinite(amountToInvestNumber)) {
+        logger.error(
+          `Invalid amountToInvest calculation result: ${amountToInvestNumber}. Calculation may have produced NaN or Infinity.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+      if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+
+      const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        logger.error("error getting extended position to decide move assets");
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      const { collateralTokenAmount } =
+        await vesuAdapter.vesuAdapter.getAssetPrices();
+
+      const {
+        collateralPrice,
+        debtPrice
+      } = await this.getAssetPrices();
+      
+
+      if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+        logger.error(
+          `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
+        logger.error(
+          `Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      
+      const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
+        await calculateAmountDistribution(
+          amountToInvest.toNumber(),
+          extendedAdapter.client,
+          extendedAdapter.config.extendedMarketName,
+          collateralPrice.price,
+          debtPrice.price,
+          collateralTokenAmount,
+          extendedPositon
+        );
+      if (
+        !vesu_amount ||
+        !extended_amount ||
+        !extended_leverage ||
+        !vesu_leverage
+      ) {
+        logger.error(
+          `Not enough amount to invest: vesu_amount=${vesu_amount}, extended_amount=${extended_amount}`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
+      return {
+        shouldInvest: true,
+        vesuAmount: vesu_amount,
+        extendedAmount: extended_amount,
+        extendedLeverage: extended_leverage,
+        vesuLeverage: vesu_leverage,
+        collateralPrice: collateralPrice.price,
+        debtPrice: debtPrice.price,
+      };
+    } catch (err) {
+      logger.error(`error deciding invest: ${err}`);
+      return {
+        shouldInvest: false,
+        vesuAmount: new Web3Number(0, 0),
+        extendedAmount: new Web3Number(0, 0),
+        extendedLeverage: 0,
+        collateralPrice: 0,
+        debtPrice: 0,
+        vesuLeverage: 0,
+      };
+    }
+  }
+
+  async shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: 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.getUnusedBalance()).amount;
+      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+
+      logger.info(`${VesuExtendedMultiplierStrategy.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
+      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+      
+      if (extendedAmount.isNegative()) {
+        projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+      }
+      
+      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+      
+      // 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(`${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[] = [];
+
+      // 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 moveAssets(
+    params: {
+      amount: Web3Number;
+      from: string;
+      to: string;
+    },
+    extendedAdapter: ExtendedAdapter,
+    vesuAdapter: VesuMultiplyAdapter
+  ): Promise<{
+    calls: Call[];
+    status: boolean;
+  }> {
+    try {
+      // Validate amount is positive before starting operations
+      if (params.amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
+        );
+        return {
+          calls: [],
+          status: false
+        };
+      }
+
+      // 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 {
+            calls: [],
+            status: false
+          };
+        }
+      }
+      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 {
+            calls: [],
+            status: false
+          };
+        }
+      }
+
+      const avnuAdapter = await this.getAvnuAdapter();
+      if (!avnuAdapter) {
+        logger.error(`avnu adapter not found: ${avnuAdapter}`);
+        return {
+          calls: [],
+          status: false
+        };
+      }
+      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
+      const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
+      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(`${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.000035, // 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 { calls: [], status: false };
+          }
+        }
+        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}`);
+          await new Promise(resolve => setTimeout(resolve, 5000));
+          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) {
+        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 {
+            calls: [],
+            status: false
+          };
+        }
+        //withdraw from vesu 
+        const vesuAmountInBTC = new Web3Number(
+          params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
+          collateralToken.decimals
+        );
+        const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
+        const calls = [];
+        const proofGroups = proofsInfo.proofs;
+        const call = this.getManageCall(
+          proofGroups,
+          await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
+        );
+        calls.push(call);
+        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 {
+          calls: calls,
+          status: true
+        };
+      } 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 {
+            calls: [],
+            status: false
+          };
+        }
+        const vesuAmountInBTC = new Web3Number(
+          params.amount.dividedBy(collateralPrice.price).toNumber(),
+          collateralToken.decimals
+        );
+        const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
+        const calls = [];
+        const proofGroups = proofsInfo.proofs;
+        const call = this.getManageCall(
+          proofGroups,
+          await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
+        );
+        calls.push(call);
+        const swapProofsInfo = avnuAdapter.getProofs(false, this.getMerkleTree());
+        const swapProofGroups = swapProofsInfo.proofs;
+        const swapCall = this.getManageCall(
+          swapProofGroups,
+          await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
+        );
+        calls.push(swapCall);
+        const proofsInfoDeposit = extendedAdapter.getProofs(
+          true,
+          this.getMerkleTree()
+        );
+        //Deposit Amount would still be in usdc
+        const proofGroupsDeposit = proofsInfoDeposit.proofs;
+        const callDeposit = this.getManageCall(
+          proofGroupsDeposit,
+          await proofsInfoDeposit.callConstructor({ amount: params.amount })
+        );
+        calls.push(callDeposit);
+        return {
+          calls: calls,
+          status: true
+        };
+      }
+      return {
+        calls: [],
+        status: false
+      };
+    } catch (err) {
+      logger.error(`error moving assets: ${err}`);
+      return {
+        calls: [],
+        status: false
+      };
+    }
+  }
+
+  async handleDeposit(): Promise<{
+    extendedAmountInBTC: Web3Number,
+    calls: Call[]
+  }> {
+    try {
+      const vesuAdapter = await this.getVesuAdapter();
+      const extendedAdapter = await this.getExtendedAdapter();
+      const avnuAdapter = await this.getAvnuAdapter();
+      if (
+        !vesuAdapter ||
+        !extendedAdapter ||
+        !extendedAdapter.client ||
+        !avnuAdapter
+      ) {
+        logger.error(
+          "vesu or extended adapter not found",
+          vesuAdapter,
+          extendedAdapter
+        );
+        return {
+          extendedAmountInBTC: new Web3Number(0, 0),
+          calls: [],
+        };
+      }
+      const extendedLeverage = calculateExtendedLevergae();
+      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, PositionTypeAvnuExtended.OPEN);
+      if (!isPriceDifferenceBetweenAvnuAndExtended) {
+        logger.error("price difference between avnu and extended doesn't fit the range");
+        return {
+          extendedAmountInBTC: new Web3Number(0, 0),
+          calls: [],
+        };
+      }
+      const position = await extendedAdapter.getAllOpenPositions();
+      if (!position) {
+        logger.error("error getting extended position", position);
+        return {
+          extendedAmountInBTC: new Web3Number(0, 0),
+          calls: [],
+        };
+      }
+      const extendedPositionValue = position.length > 0 ? parseFloat(position[0].value) : 0;
+      const BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE = BUFFER_USDC_IN_WITHDRAWAL;
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return {
+          extendedAmountInBTC: new Web3Number(0, 0),
+          calls: [],
+        };
+      }
+      const extendedHoldingAmount = new Web3Number(
+        extendedHoldings.availableForWithdrawal,
+        USDC_TOKEN_DECIMALS
+      );
+      const {
+        collateralTokenAmount,
+      } = await vesuAdapter.vesuAdapter.getAssetPrices();
+      const { collateralPrice } = await this.getAssetPrices();
+      const { vesuAmountInBTC, extendedAmountInBTC } = calculateVesUPositionSizeGivenExtended(
+        extendedPositionValue,
+        extendedHoldingAmount.minus(BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE),
+        collateralTokenAmount,
+        collateralPrice.price
+      );
+      const extendedAmountInBTCWeb3 = new Web3Number(extendedAmountInBTC, WBTC_TOKEN_DECIMALS);
+      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTCWeb3}`);
+
+      let calls: Call[] = [];
+      if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
+        const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
+        const proofGroups = proofsInfo.proofs;
+        const call = this.getManageCall(
+          proofGroups,
+          await proofsInfo.callConstructor({
+            amount: vesuAmountInBTC,
+          })
+        );
+        const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
+        if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
+          const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
+          const swapProofGroups = swapProofsInfo.proofs;
+          const swapCall = this.getManageCall(
+            swapProofGroups,
+            await swapProofsInfo.callConstructor({
+              amount: vesuAmountInBTC,
+            })
+          );
+          if(swapCall.calldata?.length && Number(swapCall.calldata.length) > 0) {
+            calls.push(swapCall);
+          } else {
+            console.error("error getting swap call from avnu", swapCall);
+            return {
+              extendedAmountInBTC: new Web3Number(0, 0),
+              calls: [],
+            };
+          }
+        }
+        calls.push(call);
+      }
+      const shortPosition = extendedAmountInBTCWeb3.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
+        extendedLeverage.toString(),
+        extendedAmountInBTCWeb3.toNumber(),
+        OrderSide.SELL
+      ) : null;
+      if (!shortPosition && extendedAmountInBTCWeb3.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
+        logger.error(`error creating short position thus no position to be opened on vesu: ${shortPosition}`);
+        return {
+          extendedAmountInBTC: new Web3Number(0, 0),
+          calls: [],
+        };
+      }
+      return {
+        extendedAmountInBTC: extendedAmountInBTCWeb3,
+        calls: calls,
+      };
+    } catch (err) {
+      logger.error(`error handling deposit: ${err}`);
+      return {
+        extendedAmountInBTC: new Web3Number(0, 0),
+        calls: [],
+      };
+    }
+  }
+
+  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);
+    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(`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 handleWithdraw(amount: Web3Number): Promise<{ calls: Call[], status: boolean }> {
+    try {
+      const usdcBalanceVaultAllocator = await this.getUnusedBalance();
+      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
+        })
+        logger.info("withdraw call", withdrawCall);
+        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 {
+        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 amountDistributionForWithdrawal =
+        await calculateAmountDistributionForWithdrawal(
+          usdcBalanceDifference,
+          collateralPrice.price,
+          collateralTokenAmount,
+          extendedPositon
+        );
+      if (!amountDistributionForWithdrawal) {
+        status = false;
+        logger.error(
+          `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
+        );
+        return {
+          calls: calls,
+          status: status
+        };
+      }
+      const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
+
+      if (status && vesu_amount.greaterThan(0)) {
+        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+          {
+            amount: vesu_amount,
+            from: Protocols.VESU.name,
+            to: Protocols.VAULT.name,
+          },
+          extendedAdapter,
+          vesuAdapter
+        );
+        status = vesuStatus;
+        calls.push(...vesuCalls);
+      }
+      if (status && extended_amount.greaterThan(0)) {
+        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+          {
+            amount: extended_amount,
+            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: status
+      };
+    } catch (err) {
+      logger.error(`error handling withdrawal: ${err}`);
+      return {
+        calls: [],
+        status: false
+      };
+    }
+  }
+
+  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();
+      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]
+    };
+  }
+
+}
+
+function getLooperSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  vaultSettings: VesuExtendedStrategySettings,
+  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 === lstSymbol
+  )!;
+  const usdcToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === underlyingSymbol
+  )!;
+
+  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.01,
+    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,
+    retryDelayForOrderStatus: minimumExtendedRetriesDelayForOrderStatus ?? 3000,
+    minimumExtendedMovementAmount: minimumExtendedMovementAmount ?? 5, //5 usdcs
+  });
+
+  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 ?? 5, //5 usdc
+  });
+
+  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+    ...baseAdapterConfig,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${vesuMultiplyAdapter.name}_${wbtcToken.symbol}_${usdcToken.symbol}`,
+    adapter: vesuMultiplyAdapter,
+  });
+
+  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(() => extendedAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        usdcToken.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: VesuExtendedStrategySettings = {
+  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,
+  minHealthFactor: 1.05,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "USDC"
+  )!,
+  quoteAmountToFetchPrice: new Web3Number(
+    "0.001",
+    Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!.decimals
+  ),
+  borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "WBTC")!],
+  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+}
+
+export const VesuExtendedTestStrategies = (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
+  return [
+    getStrategySettingsVesuExtended('WBTC', 'USDC', re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
+  ]
+}
+
+
+
+function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendUrl: string, extendedApiKey: 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, 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.ENDUR, 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.'
+  }
+}