@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.30

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

@@ -3,25 +3,43 @@ import {
   IConfig,
   IStrategyMetadata,
   TokenInfo,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  VaultType,
+  VaultPosition,
 } from "@/interfaces";
 import {
   UNIVERSAL_MANAGE_IDS,
   UniversalStrategySettings,
 } from "../universal-strategy";
-import { calculateExtendedLevergae } from "./utils/helper";
+import {
+  ExtendedSVKVesuStateManager,
+  StateManagerConfig,
+} from "./services/extended-vesu-state-manager";
+import { ExecutionService, ExecutionConfig } from "./services/executionService";
 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 {
+  LIMIT_BALANCE,
+  USDC_TOKEN_DECIMALS,
+  WALLET_ADDRESS,
+  WBTC_TOKEN_DECIMALS,
+} from "./utils/constants";
+import { ExecutionCallback } from "./types/transaction-metadata";
 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 {
+  getInvestmentSteps,
+  getFAQs,
+} from "../universal-lst-muliplier-strategy";
 import { getContractDetails } from "../universal-strategy";
 import { highlightTextWithLinks } from "@/interfaces";
 import { PositionInfo } from "../universal-adapters";
@@ -31,12 +49,11 @@ import { VesuPools } from "../universal-adapters";
 import {
   BaseAdapterConfig,
   CommonAdapter,
-  UnusedBalanceAdapter,
+  TokenTransferAdapter,
+  VesuModifyPositionAdapter,
   VesuMultiplyAdapter,
 } from "../universal-adapters";
-import { Operations } from "./services/operationService";
 import {
-  AVNU_EXCHANGE,
   AVNU_QUOTE_URL,
   AVNU_MIDDLEWARE,
   EXTENDED_CONTRACT,
@@ -45,18 +62,10 @@ 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 { VesuConfig } from "./utils/config.runtime";
 
-
-export interface VesuExtendedStrategySettings
-  extends UniversalStrategySettings {
+export interface VesuExtendedStrategySettings extends UniversalStrategySettings {
   underlyingToken: TokenInfo;
   borrowable_assets: TokenInfo[];
   targetHealthFactor: number;
@@ -64,36 +73,80 @@ export interface VesuExtendedStrategySettings
   minHealthFactor: number;
   aumOracle: ContractAddr;
   minimumWBTCDifferenceForAvnuSwap: number;
+  walletAddress: string;
 }
 
 export class VesuExtendedMultiplierStrategy<
-  S extends VesuExtendedStrategySettings
->
-  extends SVKStrategy<S>
-  implements Operations {
+  S extends VesuExtendedStrategySettings,
+> extends SVKStrategy<S> {
+  public wbtcToken: TokenInfo;
+  public usdcToken: TokenInfo;
+  public readonly stateManager: ExtendedSVKVesuStateManager;
 
   constructor(
     config: IConfig,
     pricer: PricerBase,
-    metadata: IStrategyMetadata<S>
+    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 =
+      if ((adapter.adapter as any)._vesuAdapter) {
+        (adapter.adapter as any)._vesuAdapter.networkConfig =
           this.config;
-        (adapter.adapter as VesuMultiplyAdapter).vesuAdapter.pricer =
+        (adapter.adapter as any)._vesuAdapter.pricer =
           this.pricer;
       }
     });
+    // todo check if this can be generalized
+    this.wbtcToken = Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!;
+    this.usdcToken = this.metadata.additionalInfo.borrowable_assets[0]!;
+    this.stateManager = this._initializeStateManager();
+  }
+
+  /**
+   * Extracts the required adapters from metadata and constructs the
+   * state manager used by shouldInvest / handleWithdraw.
+   */
+  private _initializeStateManager(): ExtendedSVKVesuStateManager {
+    const vesuAdapters = this.metadata.additionalInfo.adapters
+      .filter((a) => a.adapter.name === VesuMultiplyAdapter.name)
+      .map((a) => a.adapter as VesuMultiplyAdapter);
+
+    const extendedAdapterEntry = this.metadata.additionalInfo.adapters.find(
+      (a) => a.adapter.name === ExtendedAdapter.name,
+    );
+    if (!extendedAdapterEntry) {
+      throw new Error(
+        `${this.getTag()} ExtendedAdapter not found in adapters — cannot initialise state manager.`,
+      );
+    }
+
+    const stateManagerConfig: StateManagerConfig = {
+      pricer: this.pricer,
+      networkConfig: this.config,
+      vesuAdapters,
+      extendedAdapter: extendedAdapterEntry.adapter as ExtendedAdapter,
+      vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
+      walletAddress: this.metadata.additionalInfo.walletAddress,
+      assetToken: this.asset(),
+      usdcToken: this.usdcToken,
+      collateralToken: this.wbtcToken,
+      limitBalanceBufferFactor: LIMIT_BALANCE,
+    };
+
+    return new ExtendedSVKVesuStateManager(stateManagerConfig);
   }
 
   getTag() {
     return `${VesuExtendedMultiplierStrategy.name}:${this.metadata.name}`;
   }
 
+  /**
+   * Fetches current WBTC (collateral) and USDC (debt) prices from the pricer.
+   * Validates that both prices are finite and positive, throwing if not.
+   */
   async getAssetPrices() {
     const wbtcToken = Global.getDefaultTokens().find(
       (token) => token.symbol === "WBTC"
@@ -103,767 +156,157 @@ export class VesuExtendedMultiplierStrategy<
     )!;
     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,
-    };
-  }
 
+    if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+      throw new Error(
+        `${this.getTag()} Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
+      );
+    }
+    if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
+      throw new Error(
+        `${this.getTag()} Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
+      );
+    }
 
-  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,
-    };
+    return { collateralPrice, debtPrice };
   }
 
-  async getVesuAdapter(): Promise<VesuMultiplyAdapter | null> {
+  async getVesuMultiplyAdapter(): Promise<VesuMultiplyAdapter> {
     const vesuAdapter = this.metadata.additionalInfo.adapters.find(
-      (adapter) => adapter.adapter.name === VesuMultiplyAdapter.name
+      (adapter) => adapter.adapter.name === VesuMultiplyAdapter.name,
     );
     if (!vesuAdapter) {
-      logger.error("vesu adapter not found");
-      return null;
+      throw new Error(
+        `${this.getTag()} Vesu adapter not configured in metadata.`
+      );
     }
     return vesuAdapter.adapter as VesuMultiplyAdapter;
   }
 
-  async getAvnuAdapter(): Promise<AvnuAdapter | null> {
-    const avnuAdapter = this.metadata.additionalInfo.adapters.find(
-      (adapter) => adapter.adapter.name === AvnuAdapter.name
+  async getVesuModifyPositionAdapter(): Promise<VesuModifyPositionAdapter> {
+    const vesuModifyPositionAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === VesuModifyPositionAdapter.name,
     );
-    if (!avnuAdapter) {
-      logger.error("avnu adapter not found");
-      return null;
+    if (!vesuModifyPositionAdapter) {
+      throw new Error(
+        `${this.getTag()} Vesu modify position adapter not configured in metadata.`,
+      );
     }
-    return avnuAdapter.adapter as AvnuAdapter;
+    return vesuModifyPositionAdapter.adapter as VesuModifyPositionAdapter;
   }
 
-  async getExtendedAdapter(): Promise<ExtendedAdapter | null> {
-    const extendedAdapter = this.metadata.additionalInfo.adapters.find(
-      (adapter) => adapter.adapter.name === ExtendedAdapter.name
+  async getUsdcTransferAdapter(): Promise<TokenTransferAdapter> {
+    const usdcTransferAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === TokenTransferAdapter.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 })
+    if (!usdcTransferAdapter) {
+      throw new Error(
+        `${this.getTag()} Usdc transfer adapter not configured in metadata.`
       );
-      return [approveCall, transferCall, call];
-    } catch (err) {
-      logger.error(`error moving assets to vault allocator: ${err}`);
-      return [];
     }
+    return usdcTransferAdapter.adapter as TokenTransferAdapter;
   }
 
-  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.availableForTrade
+  async getAvnuAdapter(): Promise<AvnuAdapter> {
+    const avnuAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === AvnuAdapter.name,
+    );
+    if (!avnuAdapter) {
+      throw new Error(
+        `${this.getTag()} Avnu adapter not configured in metadata.`
       );
-      if (extendedAmount.plus(BUFFER_USDC_IN_WITHDRAWAL).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.plus(BUFFER_USDC_IN_WITHDRAWAL).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
-        );
-        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}`);
-            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
-      };
     }
+    return avnuAdapter.adapter as AvnuAdapter;
   }
 
-  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 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.availableForTrade,
-        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
+  async getExtendedAdapter(): Promise<ExtendedAdapter> {
+    const extendedAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === ExtendedAdapter.name,
+    );
+    if (!extendedAdapter) {
+      throw new Error(
+        `${this.getTag()} Extended adapter not configured in metadata.`
       );
-      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)) {
-          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;
+    if (!extendedAdapter.adapter || !(extendedAdapter.adapter as ExtendedAdapter).client) {
+      throw new Error(
+        `${this.getTag()} Extended adapter client not initialized.`
+      );
     }
-    logger.error(`price difference between avnu and extended doesn't fit the range, priceDifference: ${priceDifference}`);
-    return false;
+    return extendedAdapter.adapter as ExtendedAdapter;
   }
 
-  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;
+  /**
+   * Creates an ExecutionService wired to this strategy's adapters and config.
+   * Use with `stateManager.solve()` to get a SolveResult, then pass it to
+   * `executionService.execute(solveResult)` for execution.
+   *
+   * @param onExecutionEvent - Optional callback for execution lifecycle events (DB persistence, alerts, etc.)
+   * @param extendedAcceptableSlippageBps - Slippage for Extended limit orders (default: 10 = 0.1%)
+   * @param maxPriceDivergenceBps - Max price divergence between Extended and AVNU (default: 50 = 0.5%)
+   */
+  async createExecutionService(opts?: {
+    onExecutionEvent?: ExecutionCallback;
+    extendedAcceptableSlippageBps?: number;
+    maxPriceDivergenceBps?: number;
+  }): Promise<ExecutionService> {
+    const [
+      vesuMultiplyAdapter,
+      vesuModifyPositionAdapter,
+      extendedAdapter,
+      avnuAdapter,
+      usdcTransferAdapter,
+    ] =
+      await Promise.all([
+        this.getVesuMultiplyAdapter(),
+        this.getVesuModifyPositionAdapter(),
+        this.getExtendedAdapter(),
+        this.getAvnuAdapter(),
+        this.getUsdcTransferAdapter(),
+      ]);
+
+    const executionConfig: ExecutionConfig = {
+      networkConfig: this.config,
+      pricer: this.pricer,
+      vesuMultiplyAdapter,
+      vesuModifyPositionAdapter,
+      extendedAdapter,
+      avnuAdapter,
+      usdcTransferAdapter,
+      vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
+      walletAddress: this.metadata.additionalInfo.walletAddress,
+      wbtcToken: this.wbtcToken,
+      usdcToken: this.usdcToken,
+      getMerkleTree: () => this.getMerkleTree(),
+      getManageCall: (proofs, manageCalls) => this.getManageCall(proofs, manageCalls),
+      getBringLiquidityCall: (params) => this.getBringLiquidityCall(params),
+      onExecutionEvent: opts?.onExecutionEvent,
+      extendedAcceptableSlippageBps: opts?.extendedAcceptableSlippageBps,
+      maxPriceDivergenceBps: opts?.maxPriceDivergenceBps,
+    };
 
-      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
-      };
-    }
+    return new ExecutionService(executionConfig);
   }
 
-  async getAUM(): Promise<{ net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[] }> {
+  /**
+   * Calculates the total Assets Under Management across all adapters.
+   * Aggregates position values from every adapter, converts to the vault's
+   * base asset, and returns the net AUM along with the previous AUM snapshot
+   * and per-position breakdowns.
+   */
+  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);
+      let positions = await adapter.adapter.getPositions();
+      if (positions && positions.length > 0) {
+        const filteredPositions = positions;
+        allPositions.push(...filteredPositions);
+      }
     }
-
     const assetPrice = await this.pricer.getPrice(this.asset().symbol);
     let netAUM = new Web3Number(0, this.asset().decimals);
     for (let position of allPositions) {
@@ -874,6 +317,16 @@ export class VesuExtendedMultiplierStrategy<
       }
     }
 
+    // ! IMO should also include USDC in wallet.
+    const walletHoldings = await this.getWalletHoldings();
+    for (let holding of walletHoldings) {
+      if (holding.tokenInfo.address.eq(this.asset().address)) {
+        netAUM = netAUM.plus(holding.amount);
+      } else {
+        netAUM = netAUM.plus(holding.usdValue / assetPrice.price);
+      }
+    }
+
     const prevAum = await this.getPrevAUM();
     const realAUM: PositionInfo = {
       tokenInfo: this.asset(),
@@ -881,49 +334,249 @@ export class VesuExtendedMultiplierStrategy<
       usdValue: netAUM.toNumber() * assetPrice.price,
       apy: { apy: netAUM.toNumber() * assetPrice.price, type: APYType.BASE },
       remarks: AUMTypes.FINALISED,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE, // just placeholder
     };
 
     const estimatedAUMDelta: PositionInfo = {
       tokenInfo: this.asset(),
-      amount: Web3Number.fromWei('0', this.asset().decimals),
+      amount: Web3Number.fromWei("0", this.asset().decimals),
       usdValue: 0,
       apy: { apy: 0, type: APYType.BASE },
       remarks: AUMTypes.DEFISPRING,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE, // just placeholder
     };
 
     return {
       net: {
         tokenInfo: this.asset(),
         amount: netAUM,
-        usdValue: netAUM.toNumber() * assetPrice.price
-      }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]
+        usdValue: netAUM.toNumber() * assetPrice.price,
+      },
+      prevAum: prevAum,
+      splits: [realAUM, estimatedAUMDelta],
     };
   }
 
+
+  /**
+   * Computes the maximum additional USDC that can be borrowed from Vesu
+   * while keeping the strategy profitable. Uses the Extended funding rate
+   * and Vesu supply APY to derive a break-even borrow APY, then queries
+   * Vesu for the max borrowable amount at that rate.
+   */
+  async getMaxBorrowableAmount(): Promise<Web3Number> {
+    const vesuAdapter = await this.getVesuModifyPositionAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    const extendedFundingRate = new Web3Number(
+      (await extendedAdapter.getNetAPY()).toFixed(4),
+      0,
+    );
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    if (!extendedPositions || extendedPositions.length === 0) {
+      logger.warn(`${this.getTag()} getMaxBorrowableAmount: no extended positions found`);
+      return new Web3Number(0, 0);
+    }
+    const extendePositionSizeUSD = new Web3Number(
+      extendedPositions[0].value || 0,
+      0,
+    );
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuSupplyApy = vesuPositions[0].apy.apy;
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
+    );
+    const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+    const num2 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
+    const num3 = vesuDebtSizeUSD.abs();
+    const maxBorrowApy = num1.plus(num2).minus(0.1).dividedBy(num3);
+    const vesuMaxBorrowableResult =
+      await vesuAdapter._vesuAdapter.getMaxBorrowableByInterestRate(
+        this.config,
+        vesuAdapter.config.debt,
+        maxBorrowApy.toNumber(),
+      );
+    return new Web3Number(
+      vesuMaxBorrowableResult.maxDebtToHave.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
+    );
+  }
+
+  /**
+   * Returns the current health metrics for the strategy:
+   *  [0] Vesu health factor (maxLTV / actualLTV) — higher is safer.
+   *  [1] Extended margin ratio (as percentage) — higher means more margin available.
+   */
+  async getVesuHealthFactors(): Promise<number[]> {
+    const vesuAdapter = await this.getVesuModifyPositionAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0,
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0,
+    );
+    const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
+    logger.debug(`${this.getTag()} getVesuHealthFactors: actualLtv=${actualLtv.toNumber()}`);
+    const maxLtv = new Web3Number(
+      await vesuAdapter._vesuAdapter.getLTVConfig(this.config),
+      4,
+    );
+    const healthFactor = new Web3Number(
+      maxLtv.dividedBy(actualLtv).toFixed(4),
+      4,
+    );
+    logger.debug(`${this.getTag()} getVesuHealthFactors: healthFactor=${healthFactor.toNumber()}`);
+    const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
+    if (!extendedBalance) {
+      return [0, 0];
+    }
+    const extendedLeverage = new Web3Number(
+      (Number(extendedBalance.marginRatio) * 100).toFixed(4),
+      4,
+    );
+    logger.debug(`${this.getTag()} getVesuHealthFactors: extendedLeverage=${extendedLeverage.toNumber()}`);
+    return [healthFactor.toNumber(), extendedLeverage.toNumber()];
+  }
+
+  /**
+   * Calculates the weighted net APY of the strategy across all positions.
+   * Combines Vesu supply APY (scaled by 0.1 performance fee) and Extended
+   * position APY, weighted by their respective USD values.
+   * Also returns per-position APY splits.
+   */
+  async netAPY(): Promise<{
+    net: number;
+    splits: { apy: number; id: string }[];
+  }> {
+    const allPositions: PositionInfo[] = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+      if (adapter.adapter.name !== ExtendedAdapter.name) {
+        let positions = await adapter.adapter.getPositions();
+        if (positions.length > 0) {
+          allPositions.push(...positions);
+        }
+      }
+    }
+    const extendedAdapter = await this.getExtendedAdapter();
+    let vesuPositions = allPositions.filter(
+      (item) => item.protocol === Protocols.VESU,
+    );
+    vesuPositions.map((item) => {
+      item.apy.apy = item.apy.apy * 0.1;
+    });
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    if (!extendedPositions || !this.usdcToken) {
+      return {
+        net: 0,
+        splits: [],
+      };
+    }
+    const extendedPosition = extendedPositions[0] || 0;
+    const extendedEquity =
+      (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+    const extendedApy = await extendedAdapter.getNetAPY();
+    const totalHoldingsUSDValue =
+      allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) +
+      Number(extendedEquity);
+    const extendedPositionSizeMultipliedByApy =
+      Number(extendedPosition.value) * extendedApy;
+    let weightedAPYs =
+      allPositions.reduce(
+        (acc, curr) => acc + curr.apy.apy * curr.usdValue,
+        0,
+      ) + extendedPositionSizeMultipliedByApy;
+    const netAPY = weightedAPYs / totalHoldingsUSDValue;
+    logger.debug(
+      `${this.getTag()} netAPY: holdingsUsd=${totalHoldingsUSDValue}, weightedApy=${weightedAPYs}, net=${netAPY}`,
+    );
+    allPositions.push({
+      tokenInfo: this.usdcToken,
+      amount: new Web3Number(extendedPosition.size, 0),
+      usdValue: Number(extendedEquity),
+      apy: { apy: extendedApy, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.EXTENDED,
+    });
+    return {
+      net: netAPY,
+      splits: allPositions.map((p) => ({
+        apy: p.apy.apy,
+        id: p.remarks ?? "",
+      })),
+    };
+  }
+
+  /**
+   * Fetches the operator wallet's current holdings for USDC and WBTC,
+   * returning each token's balance and USD value.
+   */
+  async getWalletHoldings(): Promise<
+    {
+      tokenInfo: TokenInfo;
+      amount: Web3Number;
+      usdValue: number;
+    }[]
+  > {
+    if (!this.wbtcToken || !this.usdcToken) {
+      return [];
+    }
+    const walletAddress = this.metadata.additionalInfo.walletAddress;
+    const usdcWalletBalance = await new ERC20(this.config).balanceOf(
+      this.usdcToken.address,
+      walletAddress,
+      this.usdcToken.decimals,
+    );
+    const price = await this.pricer.getPrice(this.usdcToken.symbol);
+    const usdcUsdValue =
+      Number(usdcWalletBalance.toFixed(this.usdcToken.decimals)) * price.price;
+    return [
+      {
+        tokenInfo: this.usdcToken,
+        amount: usdcWalletBalance,
+        usdValue: usdcUsdValue,
+      }
+    ];
+  }
 }
 
+/**
+ * Configures all adapters (Vesu, Extended, Avnu, TokenTransfer)
+ * and registers their leaf adapters on the vault settings. This is the central
+ * wiring function that connects the strategy to its underlying protocol adapters.
+ */
 function getLooperSettings(
-  lstSymbol: string,
+  collateralSymbol: string,
   underlyingSymbol: string,
   vaultSettings: VesuExtendedStrategySettings,
   pool1: ContractAddr,
-  extendedBackendUrl: string,
-  extendedApiKey: string,
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
   vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number,
 ) {
   vaultSettings.leafAdapters = [];
 
   const wbtcToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === lstSymbol
+    (token) => token.symbol === collateralSymbol,
   )!;
   const usdcToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === underlyingSymbol
+    (token) => token.symbol === underlyingSymbol,
   )!;
 
   const baseAdapterConfig: BaseAdapterConfig = {
-    baseToken: wbtcToken,
+    baseToken: usdcToken,
     supportedPositions: [
       { asset: usdcToken, isDebt: true },
       { asset: wbtcToken, isDebt: false },
@@ -940,29 +593,36 @@ function getLooperSettings(
     avnuContract: AVNU_MIDDLEWARE,
     slippage: 0.01,
     baseUrl: AVNU_QUOTE_URL,
+    minimumExtendedPriceDifferenceForSwapOpen:
+      minimumExtendedPriceDifferenceForSwapOpen,
+    maximumExtendedPriceDifferenceForSwapClosing:
+      maximumExtendedPriceDifferenceForSwapClosing,
   });
 
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
     supportedPositions: [
-      { asset: usdcToken, isDebt: true },
+      { asset: usdcToken, isDebt: false },
     ],
     vaultIdExtended: vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
-    extendedBackendUrl: extendedBackendUrl,
-    extendedApiKey: extendedApiKey,
+    extendedBackendWriteUrl: extendedBackendWriteUrl,
+    extendedBackendReadUrl: extendedBackendReadUrl,
     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,
+    marginToken: usdcToken,
     targetHealthFactor: vaultSettings.targetHealthFactor,
     minHealthFactor: vaultSettings.minHealthFactor,
     quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
@@ -971,10 +631,31 @@ function getLooperSettings(
       { asset: wbtcToken, isDebt: false },
       { asset: usdcToken, isDebt: true },
     ],
+    minimumVesuMovementAmount: minimumVesuMovementAmount ?? 5, //5 usdc
+  });
+
+  const vesuModifyPositionMaxLtv = VesuConfig.maxLtv;
+  const vesuModifyPositionTargetLtv = VesuConfig.targetLtv;
+  const vesuModifyPositionAdapter = new VesuModifyPositionAdapter({
+    poolId: pool1,
+    collateral: wbtcToken,
+    debt: usdcToken,
+    targetLtv: vesuModifyPositionTargetLtv,
+    maxLtv: vesuModifyPositionMaxLtv,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: wbtcToken, isDebt: false },
+      { asset: usdcToken, isDebt: true },
+    ],
   });
 
-  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+  // Transfers USDC between the vault allocator (fromAddress) and the operator wallet (toAddress)
+  const usdcTransferAdapter = new TokenTransferAdapter({
     ...baseAdapterConfig,
+    baseToken: usdcToken,
+    supportedPositions: [{ asset: usdcToken, isDebt: false }],
+    fromAddress: vaultSettings.vaultAllocator,
+    toAddress: ContractAddr.from(vaultSettings.walletAddress),
   });
 
   vaultSettings.adapters.push({
@@ -983,8 +664,13 @@ function getLooperSettings(
   });
 
   vaultSettings.adapters.push({
-    id: `${unusedBalanceAdapter.name}_${wbtcToken.symbol}`,
-    adapter: unusedBalanceAdapter,
+    id: `${vesuModifyPositionAdapter.name}_${wbtcToken.symbol}_${usdcToken.symbol}`,
+    adapter: vesuModifyPositionAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${usdcTransferAdapter.name}_${usdcToken.symbol}`,
+    adapter: usdcTransferAdapter,
   });
 
   vaultSettings.adapters.push({
@@ -1002,44 +688,43 @@ function getLooperSettings(
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
     manager: vaultSettings.manager,
-    asset: wbtcToken.address,
+    asset: usdcToken.address,
   });
 
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() =>
-    vesuMultiplyAdapter.getWithdrawLeaf()
-  );
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.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(() => usdcTransferAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => usdcTransferAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(
     commonAdapter
       .getApproveAdapter(
         usdcToken.address,
         vaultSettings.vaultAddress,
-        UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY
+        UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY,
       )
-      .bind(commonAdapter)
+      .bind(commonAdapter),
   );
 
   vaultSettings.leafAdapters.push(
     commonAdapter
       .getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
-      .bind(commonAdapter)
+      .bind(commonAdapter),
   );
   return vaultSettings;
 }
 
-
 function getDescription(tokenSymbol: string, underlyingSymbol: string) {
   return VaultDescription(tokenSymbol, underlyingSymbol);
 }
 
 export default function VaultDescription(
   lstSymbol: string,
-  underlyingSymbol: string
+  underlyingSymbol: string,
 ) {
   const containerStyle = {
     maxWidth: "800px",
@@ -1052,26 +737,64 @@ export default function VaultDescription(
 
   return (
     <div style={containerStyle}>
-      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>Liquidation risk managed leverged {lstSymbol} Vault</h1>
+      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>
+        Liquidation risk managed leverged {lstSymbol} Vault
+      </h1>
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault, auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by borrow {underlyingSymbol}. Borrowed amount
-        is swapped to {lstSymbol} to create leverage. Depositors receive vault shares that
-        represent a proportional claim on the underlying assets and accrued yield.
+        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault,
+        auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by
+        borrow {underlyingSymbol}. Borrowed amount is swapped to {lstSymbol} to
+        create leverage. Depositors receive vault shares that represent a
+        proportional claim on the underlying assets and accrued yield.
       </p>
 
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This vault uses Vesu for lending and borrowing. The oracle used by this pool is a {highlightTextWithLinks("conversion rate oracle", [{ highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate" }])}
-        {" "}which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.
+        This vault uses Vesu for lending and borrowing. The oracle used by this
+        pool is a{" "}
+        {highlightTextWithLinks("conversion rate oracle", [
+          {
+            highlight: "conversion rate oracle",
+            link: "https://docs.pragma.build/starknet/development#conversion-rate",
+          },
+        ])}{" "}
+        which is resilient to liquidity issues and price volatility, hence
+        reducing the risk of liquidation. However, overtime, if left
+        un-monitored, debt can increase enough to trigger a liquidation. But no
+        worries, our continuous monitoring systems look for situations with
+        reduced health factor and balance collateral/debt to bring it back to
+        safe levels. With Troves, you can have a peaceful sleep.
       </p>
 
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Withdrawals:</strong> Requests can take up to <strong>1-2 hours</strong> to process as the vault unwinds and settles routing.
+          <strong>Withdrawals:</strong> Requests can take up to{" "}
+          <strong>1-2 hours</strong> to process as the vault unwinds and settles
+          routing.
         </p>
       </div>
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited Tokens remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on Yield token's APY, its only on added gain.
+          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are
+          gradually increased over time. Until caps are raised, deposited Tokens
+          remain in the vault, generating a shared net return for all
+          depositors. There is no additional fee taken by Troves on Yield
+          token's APY, its only on added gain.
         </p>
       </div>
       {/* <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
@@ -1084,57 +807,205 @@ export default function VaultDescription(
 }
 
 const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
-  vaultAddress: ContractAddr.from("0x520a2e945dd0762e5284fc1b012f62ca04e238e105eb362d5e0ce208928729d"),
-  manager: ContractAddr.from("0x6abe24d31cbc16d7c4acb2421a826f96273e225b4a2d168d91e65123da0bfb9"),
-  vaultAllocator: ContractAddr.from("0x6e4f716e22efb164ee4a831233e513f45396ad3be4cff3c07386be0226febed"),
-  redeemRequestNFT: ContractAddr.from("0x66060e1874e05506b18e6029188ec49bf231a411ad57642311bbdf3cb22e5f"),
-  aumOracle: ContractAddr.from("0x301d883b9b45c76132638e39326b3f464c492599623263d405ec0df991e27ab"),
+  vaultAddress: ContractAddr.from(
+    "0x772d6cf5038c18ff5ab89f8945017bbf4d2c6959891339975c70a4f74ac6c8e",
+  ),
+  manager: ContractAddr.from(
+    "0x3340c9d7231838e2dccff72b9004f1598a74e65c74b954f07fe1ea19d04a625",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x537353b35eee5ca2d9a45eb646977baddd4e89ce870a231dcada79884117292",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x6117d1a8c72c0457948083757e1a17ee8c0833b969d5c959b629e5f8feb56ec",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x6d7d68045bf5e0b5a4cec43241549851cb9645f7a73a20894152165dbe7083a",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
   minHealthFactor: 1.05,
   underlyingToken: Global.getDefaultTokens().find(
-    (token) => token.symbol === "USDC"
+    (token) => token.symbol === "USDC",
   )!,
   quoteAmountToFetchPrice: new Web3Number(
     "0.001",
-    Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!.decimals
+    Global.getDefaultTokens().find((token) => token.symbol === "WBTC")!
+      .decimals,
   ),
-  borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "WBTC")!],
+  borrowable_assets: [
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")!,
+  ],
   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),
-  ]
-}
-
+  walletAddress: '0x024b563C1C7d41B32BF4EFB9F38828508a65Be2d6e25268E9f63F22C5e9E51c5',
+};
 
+const pureUsdc: VesuExtendedStrategySettings = {
+  vaultAddress: ContractAddr.from(
+    "0x745c972db65bdee10022fd875dd328c7f40a90849135b6a0f875a40f3c632ae",
+  ),
+  manager: ContractAddr.from(
+    "0x364e0894edefb616ec090f57f5c0274517fcd98ab276ae1f021c5e962fa1deb",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x6fceed28e03a96091877568893df0dd89b9bb80fec30da2b742dacbd5526179",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x501c2b87728e22c6dfcebe4c0b2b3a9fba5845606e4d59fa7bf591badcbb42",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x6ccd95f5765242695d3c75e1440b1d0b30efac8babb864ce15729977b97cb82",
+  ),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.4,
+  minHealthFactor: 1.35,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "USDC",
+  )!,
+  quoteAmountToFetchPrice: new Web3Number(
+    "0.001",
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")!
+      .decimals,
+  ),
+  borrowable_assets: [
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")!,
+  ],
+  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+  walletAddress: '0x058571C23da5FEdd4e36003FAE3fE2fA9782f2692E552f081839142B10770D0B',
+};
 
-function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number): IStrategyMetadata<VesuExtendedStrategySettings> {
+export const VesuExtendedTestStrategies = (
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
+  vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number,
+): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
+  return [
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      re7UsdcPrimeDevansh,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing,
+    ),
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      pureUsdc,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing,
+    ),
+  ];
+};
+
+/**
+ * Constructs a complete IStrategyMetadata object for a Vesu-Extended strategy,
+ * including adapter wiring, risk configuration, FAQ, and UI description.
+ */
+function getStrategySettingsVesuExtended(
+  collateralSymbol: string,
+  underlyingSymbol: string,
+  addresses: VesuExtendedStrategySettings,
+  isPreview: boolean = false,
+  isLST: boolean,
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
+  vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number,
+): IStrategyMetadata<VesuExtendedStrategySettings> {
   return {
+    id: `extended_${underlyingSymbol.toLowerCase()}_test`,
     name: `Extended Test ${underlyingSymbol}`,
-    description: getDescription(lstSymbol, underlyingSymbol),
+    description: getDescription(collateralSymbol, 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),
+    type: "Other",
+    vaultType: {
+      type: VaultType.DELTA_NEUTRAL,
+      description: "Delta Neutral strategy using extended position on Vesu"
+    },
+    depositTokens: [
+      Global.getDefaultTokens().find(
+        (token) => token.symbol === 'WBTC',
+      )!,
+    ],
+    additionalInfo: getLooperSettings(
+      collateralSymbol,
+      underlyingSymbol,
+      addresses,
+      VesuPools.Re7USDCPrime,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing,
+    ),
     risk: {
       riskFactor: _riskFactor,
       netRisk:
         _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
         _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-      notARisks: getNoRiskTags(_riskFactor)
+      notARisks: getNoRiskTags(_riskFactor),
     },
     auditUrl: AUDIT_URL,
     protocols: [Protocols.ENDUR, Protocols.VESU],
-    maxTVL: Web3Number.fromWei(0, 18),
     contractDetails: getContractDetails(addresses),
-    faqs: getFAQs(lstSymbol, underlyingSymbol, isLST),
-    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    faqs: getFAQs(collateralSymbol, underlyingSymbol, isLST),
+    investmentSteps: getInvestmentSteps(collateralSymbol, underlyingSymbol),
     isPreview: isPreview,
-    apyMethodology: isLST ? 'Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.' : 'Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.'
-  }
-}
+    apyMethodology: isLST
+      ? "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown."
+      : "Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
+    security: {
+      auditStatus: AuditStatus.NOT_AUDITED,
+      sourceCode: {
+        type: SourceCodeType.OPEN_SOURCE,
+        contractLink: AUDIT_URL,
+      },
+      accessControl: {
+        type: AccessControlType.MULTISIG_ACCOUNT,
+        addresses: [addresses.vaultAddress],
+        timeLock: "None",
+      },
+    },
+    redemptionInfo: {
+      instantWithdrawalVault: InstantWithdrawalVault.NO,
+      redemptionsInfo: [{
+        title: "Up to $500k",
+        description: "1-24 hours",
+      }],
+      alerts: [],
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null,
+  };
+}