@strkfarm/sdk 1.1.70 → 2.0.0-dev.2

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

@@ -0,0 +1,1134 @@
+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, 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";
+
+
+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 {
+      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 {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      const balance = await this.getUnusedBalance();
+      const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
+      /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
+      const amountToInvest = balance.amount.plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).minus(LIMIT_BALANCE);
+
+      if (amountToInvest.lessThan(0)) {
+        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();
+      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,
+        };
+      }
+      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();
+      let calls: Call[] = [];
+      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        logger.error(
+          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+        );
+        return calls;
+      }
+      if (extendedAmount.lessThan(0)) {
+        try {
+          const {calls: extendedCalls, status: extendedStatus} = await this.moveAssets(
+            {
+              to: Protocols.VAULT.name,
+              from: Protocols.EXTENDED.name,
+              amount: extendedAmount.abs(),
+            },
+            extendedAdapter,
+            vesuAdapter
+          );
+          //If withdrawal succesfull, then do further
+          if(extendedStatus){
+          calls.push(...extendedCalls);
+          }else{
+            return [];
+          }
+        } catch (err) {
+          logger.error(`Failed moving assets to vault: ${err}`);
+        }
+      }
+
+      if (vesuAmount.lessThan(0)) {
+        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}`);
+        }
+      }
+
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return calls;
+      }
+      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+      const usdcAmountOnExtended = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+      if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(0)) {
+        //move assets to extended
+        try {
+          const {calls: extendedCalls} = await this.moveAssets(
+            {
+              to: Protocols.EXTENDED.name,
+              from: Protocols.VAULT.name,
+              amount: extendedAmount.minus(usdcAmountOnExtended),
+            },
+            extendedAdapter,
+            vesuAdapter
+          );
+          calls.push(...extendedCalls);
+        } catch (err) {
+          logger.error(`Failed moving assets to extended: ${err}`);
+        }
+      }
+      if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
+        //move assets to vesu
+        try {
+          const {calls: vesuCalls, status: vesuStatus} = await this.moveAssets(
+            {
+              to: Protocols.VAULT.name,
+              from: Protocols.EXTENDED.name,
+              amount: vesuAmount.minus(usdcAmountInWallet),
+            },
+            extendedAdapter,
+            vesuAdapter
+          );
+          if(!vesuStatus){
+            return [];
+          }
+          calls.push(...vesuCalls);
+        } catch (err) {
+          logger.error(`Failed moving assets to vault: ${err}`);
+        }
+      }
+      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 {
+      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
+        );
+      
+        const leftAmountAfterWithdrawalAmountInAccount = params.amount.minus(extendedHoldingAmount);
+        const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
+        const openLongPosition = await extendedAdapter.createOrder(
+          extendedLeverage.toString(),
+          btcAmount.toNumber(),
+          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}`);
+          await new Promise(resolve => setTimeout(resolve, 10000));
+          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 
+        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);
+        return {
+          calls: calls,
+          status: true
+        };
+      } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
+        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);
+      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 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,
+        collateralTokenAmount,
+        collateralPrice.price
+      );
+     logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
+     
+      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)) {
+          logger.info(`WBTC amount in vault allocator is less than vesu amount required in WBTC thus swapping, wbtcAmountInVaultAllocator: ${wbtcAmountInVaultAllocator}, vesuAmountInBTC: ${vesuAmountInBTC}`);
+          const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
+          const swapProofGroups = swapProofsInfo.proofs;
+          const swapCall = this.getManageCall(
+            swapProofGroups,
+            await swapProofsInfo.callConstructor({
+              amount: vesuAmountInBTC,
+            })
+          );
+          calls.push(swapCall);
+        }
+        calls.push(call);
+      }
+
+      const shortPosition = extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
+        extendedLeverage.toString(),
+        extendedAmountInBTC.toNumber(),
+        OrderSide.SELL
+      ) : null;
+      if (!shortPosition && extendedAmountInBTC.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: extendedAmountInBTC,
+        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): 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;
+    }
+    const priceDifference = price.minus(btcPriceAvnu).toNumber();
+    if (priceDifference < MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED && priceDifference > MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED) {
+      return true;
+    }
+    logger.error(`price difference between avnu and extended doesn't fit the range, priceDifference: ${priceDifference}`);
+    return false;
+  }
+
+  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,
+) {
+  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,
+  });
+
+  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,
+  });
+
+  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 },
+    ],
+  });
+
+  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());
+  // Doubt here, should this be usdcToken.address, or wbtcToken.address?
+  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("0x520a2e945dd0762e5284fc1b012f62ca04e238e105eb362d5e0ce208928729d"),
+  manager: ContractAddr.from("0x6abe24d31cbc16d7c4acb2421a826f96273e225b4a2d168d91e65123da0bfb9"),
+  vaultAllocator: ContractAddr.from("0x6e4f716e22efb164ee4a831233e513f45396ad3be4cff3c07386be0226febed"),
+  redeemRequestNFT: ContractAddr.from("0x66060e1874e05506b18e6029188ec49bf231a411ad57642311bbdf3cb22e5f"),
+  aumOracle: ContractAddr.from("0x301d883b9b45c76132638e39326b3f464c492599623263d405ec0df991e27ab"),
+  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): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
+  return [
+    getStrategySettingsVesuExtended('WBTC', 'USDC', re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended),
+  ]
+}
+
+
+
+function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: 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),
+    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.'
+  }
+}