@strkfarm/sdk 2.0.0-dev.26 → 2.0.0-dev.28

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

@@ -3,37 +3,37 @@ import {
   IConfig,
   IStrategyMetadata,
   TokenInfo,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  VaultType,
+  VaultPosition,
 } from "@/interfaces";
 import {
   UNIVERSAL_MANAGE_IDS,
   UniversalStrategySettings,
 } from "../universal-strategy";
 import {
-  calculateDebtAmount,
-  calculateDeltaDebtAmount,
-  calculateExtendedLevergae,
-  calculatePositionToCloseToWithdrawAmount,
-} from "./utils/helper";
+  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,
   LIMIT_BALANCE,
-  LIMIT_BALANCE_VALUE,
-  MAX_LTV_BTC_USDC,
-  MINIMUM_EXTENDED_POSITION_SIZE,
   USDC_TOKEN_DECIMALS,
   WALLET_ADDRESS,
   WBTC_TOKEN_DECIMALS,
 } from "./utils/constants";
-import { CycleType } from "./types/transaction-metadata";
+import { 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 {
@@ -49,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,
@@ -63,22 +62,11 @@ import { PricerFromApi } from "@/modules";
 import { ExtendedAdapter } from "../universal-adapters/extended-adapter";
 import { SVKStrategy } from "../svk-strategy";
 import { AvnuAdapter } from "../universal-adapters/avnu-adapter";
-import {
-  calculateAmountDistribution,
-  calculateAmountDistributionForWithdrawal,
-  calculateVesuLeverage,
-  calculateVesUPositionSizeGivenExtended,
-} from "./utils/helper";
 import { SingleTokenInfo } from "../base-strategy";
-import { Call } from "starknet";
-import { PositionTypeAvnuExtended } from "../universal-strategy";
-import {
-  TransactionMetadata,
-  TransactionResult,
-} from "./types/transaction-metadata";
+import { UsdcToUsdceAdapter } from "../universal-adapters/usdc<>usdce-adapter";
+import { VesuConfig } from "./utils/config.runtime";
 
-export interface VesuExtendedStrategySettings
-  extends UniversalStrategySettings {
+export interface VesuExtendedStrategySettings extends UniversalStrategySettings {
   underlyingToken: TokenInfo;
   borrowable_assets: TokenInfo[];
   targetHealthFactor: number;
@@ -90,33 +78,81 @@ export interface VesuExtendedStrategySettings
 }
 
 export class VesuExtendedMultiplierStrategy<
-    S extends VesuExtendedStrategySettings
-  >
-  extends SVKStrategy<S>
-  implements Operations
-{
+  S extends VesuExtendedStrategySettings,
+> extends SVKStrategy<S> {
+  public wbtcToken: TokenInfo;
+  public usdcToken: TokenInfo;
+  public usdceToken: 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.usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC.e",
+    )!;
+
+    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: Global.getDefaultTokens().find((token) => token.symbol === 'USDC')!, // ! TODO change to asset() latest
+      usdceToken: this.usdceToken,
+      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"
@@ -126,1633 +162,160 @@ 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 getVesuAdapter(): 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 getUsdceTransferAdapter(): Promise<TokenTransferAdapter> {
+    const usdceTransferAdapter = 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<{
-    calls: Call[];
-    status: boolean;
-  }> {
-    try {
-      const usdceToken = Global.getDefaultTokens().find(
-        (token) => token.symbol === "USDCe"
-      )!;
-      const walletBalance = await new ERC20(this.config).balanceOf(
-        usdceToken.address,
-        WALLET_ADDRESS,
-        usdceToken.decimals
-      );
-      logger.info(
-        `${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`
-      );
-      const amountToBeTransferred = amount.minimum(walletBalance);
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`
-      );
-
-      if (amountToBeTransferred.lessThan(0)) {
-        logger.error(
-          `${
-            VesuExtendedMultiplierStrategy.name
-          }::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`
-        );
-        return {
-          calls: [],
-          status: false,
-        };
-      }
-
-      const approveCall = new ERC20(this.config).approve(
-        usdceToken.address,
-        this.metadata.additionalInfo.vaultAllocator,
-        amountToBeTransferred
-      );
-      const transferCall = new ERC20(this.config).transfer(
-        usdceToken.address,
-        this.metadata.additionalInfo.vaultAllocator,
-        amountToBeTransferred
-      );
-      const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
-        this.getMerkleTree()
+    if (!usdceTransferAdapter) {
+      throw new Error(
+        `${this.getTag()} Usdce transfer adapter not configured in metadata.`
       );
-      const proofGroups = proofsInfo.proofs;
-      const call = this.getManageCall(
-        proofGroups,
-        await proofsInfo.callConstructor({ amount: amountToBeTransferred })
-      );
-      return {
-        calls: [approveCall, transferCall, call],
-        status: true,
-      };
-    } catch (err) {
-      logger.error(`error moving assets to vault allocator: ${err}`);
-      return {
-        calls: [],
-        status: false,
-      };
     }
+    return usdceTransferAdapter.adapter as TokenTransferAdapter;
   }
 
-  async shouldInvest(): Promise<{
-    shouldInvest: boolean;
-    vesuAmount: Web3Number;
-    extendedAmount: Web3Number;
-    extendedLeverage: number;
-    collateralPrice: number;
-    debtPrice: number;
-    vesuLeverage: number;
-    debtAmountToBeRepaid: Web3Number;
-  }> {
-    try {
-      logger.info(
-        `${VesuExtendedMultiplierStrategy.name}::shouldInvest starting`
-      );
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`
-      );
-
-      if (!vesuAdapter) {
-        logger.error(
-          `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      if (!extendedAdapter) {
-        logger.error(
-          `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      if (!extendedAdapter.client) {
-        logger.error(
-          `Extended adapter client not initialized. This may be a temporary initialization failure - check network connectivity and API availability.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-
-      logger.info(
-        `${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`
-      );
-      const balance = await this.getUnusedBalance();
-
-      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
-        logger.error(
-          `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      logger.info(
-        `${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`
-      );
-      const usdcBalanceOnExtended =
-        await extendedAdapter.getExtendedDepositAmount();
-
-      if (usdcBalanceOnExtended) {
-        const availableForWithdrawal = parseFloat(
-          usdcBalanceOnExtended.availableForWithdrawal
-        );
-        if (
-          !Number.isFinite(availableForWithdrawal) ||
-          availableForWithdrawal < 0
-        ) {
-          logger.error(
-            `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
-          );
-          return {
-            shouldInvest: false,
-            vesuAmount: new Web3Number(0, 0),
-            extendedAmount: new Web3Number(0, 0),
-            extendedLeverage: 0,
-            collateralPrice: 0,
-            debtPrice: 0,
-            vesuLeverage: 0,
-            debtAmountToBeRepaid: new Web3Number(0, 0),
-          };
-        }
-      }
-
-      /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
-      const amountToInvest = new Web3Number(
-        balance.usdValue,
-        USDC_TOKEN_DECIMALS
-      )
-        .plus(usdcBalanceOnExtended?.availableForTrade ?? 0)
-        .multipliedBy(1 - LIMIT_BALANCE);
-
-      const amountToInvestNumber = amountToInvest.toNumber();
-      if (!Number.isFinite(amountToInvestNumber)) {
-        logger.error(
-          `Invalid amountToInvest calculation result: ${amountToInvestNumber}. Calculation may have produced NaN or Infinity.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-
-      logger.info(
-        `${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`
-      );
-
-      if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 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,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      const { collateralTokenAmount, debtTokenAmount } =
-        await vesuAdapter.vesuAdapter.getAssetPrices();
-
-      const { collateralPrice, debtPrice } = await this.getAssetPrices();
-
-      if (
-        !Number.isFinite(collateralPrice.price) ||
-        collateralPrice.price <= 0
-      ) {
-        logger.error(
-          `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
-        logger.error(
-          `Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
-        );
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-
-      const debtAmountToBeRepaid = calculateDeltaDebtAmount(
-        MAX_LTV_BTC_USDC,
-        collateralTokenAmount,
-        debtTokenAmount,
-        collateralPrice.price,
-        debtPrice.price,
-        this.metadata.additionalInfo.targetHealthFactor
-      );
-      if (!debtAmountToBeRepaid) {
-        logger.error("error calculating debt amount to be repaid");
-        return {
-          shouldInvest: false,
-          vesuAmount: new Web3Number(0, 0),
-          extendedAmount: new Web3Number(0, 0),
-          extendedLeverage: 0,
-          collateralPrice: 0,
-          debtPrice: 0,
-          vesuLeverage: 0,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::shouldInvest debtAmountToBeRepaid: ${debtAmountToBeRepaid.toNumber()}`
-      );
-      /**
-       * Since the debt amount is negative, we need to add it to the amount to invest
-       * to maintain the ltv
-       */
-      const amountToInvestAfterRepayingDebt =
-        amountToInvest.plus(debtAmountToBeRepaid);
-      const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
-        await calculateAmountDistribution(
-          amountToInvestAfterRepayingDebt.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,
-          debtAmountToBeRepaid: new Web3Number(0, 0),
-        };
-      }
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`
+  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.`
       );
-      return {
-        shouldInvest: true,
-        vesuAmount: vesu_amount,
-        extendedAmount: extended_amount,
-        extendedLeverage: extended_leverage,
-        vesuLeverage: vesu_leverage,
-        collateralPrice: collateralPrice.price,
-        debtPrice: debtPrice.price,
-        debtAmountToBeRepaid: debtAmountToBeRepaid,
-      };
-    } 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,
-        debtAmountToBeRepaid: new Web3Number(0, 0),
-      };
     }
+    return avnuAdapter.adapter as AvnuAdapter;
   }
 
-  async shouldMoveAssets(
-    extendedAmount: Web3Number,
-    vesuAmount: Web3Number
-  ): Promise<TransactionResult[]> {
-    try {
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
-        logger.error(
-          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
-        );
-        return [];
-      }
-
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return [];
-      }
-      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
-      /**
-       * Trade is the correct metric, since we can close position for some vesu amount, otherwise underutilisation of funds will be a huge issue
-       */
-      const usdcAmountOnExtendedAvailableForTrade = parseFloat(
-        extendedHoldings.availableForTrade
-      );
-
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForTrade}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`
-      );
-
-      let totalExtendedWithdrawal = new Web3Number(0, USDC_TOKEN_DECIMALS);
-      let totalExtendedDeposit = new Web3Number(0, USDC_TOKEN_DECIMALS);
-
-      if (
-        extendedAmount.isNegative() &&
-        extendedAmount
-          .abs()
-          .greaterThan(extendedAdapter.minimumExtendedMovementAmount)
-      ) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
-          extendedAmount.abs()
-        );
-      }
-
-      // Calculate remaining Extended difference (target vs current)
-      // If extendedAmount was negative, we've already accounted for that withdrawal
-      // So we calculate based on what Extended will be after that withdrawal
-      const extendedTargetAmount = extendedAmount.abs(); // Use absolute value as target
-      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForTrade;
-
-      if (extendedAmount.isNegative()) {
-        projectedExtendedBalance =
-          projectedExtendedBalance - extendedAmount.abs().toNumber();
-      }
-
-      const extendedAmountDifference = extendedTargetAmount.minus(
-        projectedExtendedBalance
-      );
-      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
-
-      // Track additional Extended movements
-      if (extendedAmountDifference.lessThan(0)) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
-          extendedAmountDifferenceAbs
-        );
-      } else if (extendedAmountDifference.greaterThan(0)) {
-        totalExtendedDeposit = totalExtendedDeposit.plus(
-          extendedAmountDifference
-        );
-      }
-
-      const vesuTargetAmount = vesuAmount.abs();
-      const projectedWalletBalance = usdcAmountInWallet
-        .plus(totalExtendedWithdrawal)
-        .minus(totalExtendedDeposit);
-
-      let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
-      const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
-
-      logger.info(
-        `${
-          VesuExtendedMultiplierStrategy.name
-        }::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`
+  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.`
       );
-      let transactionResults: TransactionResult[] = [];
-
-      // Handle negative extendedAmount (initial withdrawal needed)
-      if (
-        extendedAmount.isNegative() &&
-        extendedAmount
-          .abs()
-          .greaterThan(extendedAdapter.minimumExtendedMovementAmount)
-      ) {
-        try {
-          const {
-            calls: extendedCalls,
-            status: extendedStatus,
-            transactionMetadata: extendedTransactionMetadata,
-          } = await this.moveAssets(
-            {
-              to: Protocols.VAULT.name,
-              from: Protocols.EXTENDED.name,
-              amount: extendedAmount.abs(),
-              cycleType: CycleType.INVESTMENT,
-            },
-            extendedAdapter,
-            vesuAdapter
-          );
-          if (extendedStatus) {
-            transactionResults.push({
-              status: extendedStatus,
-              calls: extendedCalls,
-              transactionMetadata: {
-                ...extendedTransactionMetadata,
-                transactionType: "DEPOSIT",
-              },
-            });
-          } else {
-            return [
-              this.createTransactionResult(
-                [],
-                false,
-                {
-                  from: Protocols.EXTENDED.name,
-                  to: Protocols.VAULT.name,
-                  amount: extendedAmount.abs(),
-                },
-                "NONE",
-                CycleType.INVESTMENT
-              ),
-            ];
-          }
-        } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
-          return [
-            this.createTransactionResult(
-              [],
-              false,
-              {
-                from: Protocols.EXTENDED.name,
-                to: Protocols.VAULT.name,
-                amount: extendedAmount.abs(),
-              },
-              "NONE",
-              CycleType.INVESTMENT
-            ),
-          ];
-        }
-      }
-
-      if (
-        vesuAmount.isNegative() &&
-        vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)
-      ) {
-        try {
-          const {
-            calls: vesuCalls,
-            status: vesuStatus,
-            transactionMetadata: vesuTransactionMetadata,
-          } = await this.moveAssets(
-            {
-              to: Protocols.EXTENDED.name,
-              from: Protocols.VESU.name,
-              amount: vesuAmount.abs(),
-              cycleType: CycleType.INVESTMENT,
-            },
-            extendedAdapter,
-            vesuAdapter
-          );
-          if (!vesuStatus) {
-            return [
-              this.createTransactionResult(
-                [],
-                false,
-                {
-                  from: Protocols.VESU.name,
-                  to: Protocols.EXTENDED.name,
-                  amount: vesuAmount.abs(),
-                },
-                "NONE",
-                CycleType.INVESTMENT
-              ),
-            ];
-          }
-          transactionResults.push({
-            status: vesuStatus,
-            calls: vesuCalls,
-            transactionMetadata: {
-              ...vesuTransactionMetadata,
-              transactionType: "DEPOSIT",
-            },
-          });
-        } catch (err) {
-          logger.error(
-            `Failed moving assets to extended via vault allocator: ${err}`
-          );
-          return [
-            this.createTransactionResult(
-              [],
-              false,
-              {
-                from: Protocols.VESU.name,
-                to: Protocols.EXTENDED.name,
-                amount: vesuAmount.abs(),
-              },
-              "NONE",
-              CycleType.INVESTMENT
-            ),
-          ];
-        }
-      }
-
-      // Handle Extended adjustments based on calculated difference
-      if (
-        extendedAmountDifferenceAbs.greaterThan(
-          extendedAdapter.minimumExtendedMovementAmount
-        )
-      ) {
-        if (extendedAmountDifference.greaterThan(0)) {
-          try {
-            const {
-              calls: extendedCalls,
-              status: extendedStatus,
-              transactionMetadata: extendedTransactionMetadata,
-            } = await this.moveAssets(
-              {
-                to: Protocols.EXTENDED.name,
-                from: Protocols.VAULT.name,
-                amount: extendedAmountDifference,
-                cycleType: CycleType.INVESTMENT,
-              },
-              extendedAdapter,
-              vesuAdapter
-            );
-            if (extendedStatus) {
-              transactionResults.push({
-                status: extendedStatus,
-                calls: extendedCalls,
-                transactionMetadata: extendedTransactionMetadata,
-              });
-            } else {
-              logger.error(
-                `Failed to move assets to extended - operation returned false status`
-              );
-              return [
-                this.createTransactionResult(
-                  [],
-                  false,
-                  {
-                    from: Protocols.VAULT.name,
-                    to: Protocols.EXTENDED.name,
-                    amount: extendedAmountDifference,
-                  },
-                  "NONE",
-                  CycleType.INVESTMENT
-                ),
-              ];
-            }
-          } catch (err) {
-            logger.error(`Failed moving assets to extended: ${err}`);
-            return [
-              this.createTransactionResult(
-                [],
-                false,
-                {
-                  from: Protocols.VAULT.name,
-                  to: Protocols.EXTENDED.name,
-                  amount: extendedAmountDifference,
-                },
-                "NONE",
-                CycleType.INVESTMENT
-              ),
-            ];
-          }
-        } else if (extendedAmountDifference.lessThan(0)) {
-          try {
-            const {
-              calls: extendedCalls,
-              status: extendedStatus,
-              transactionMetadata: extendedTransactionMetadata,
-            } = await this.moveAssets(
-              {
-                to: Protocols.VAULT.name,
-                from: Protocols.EXTENDED.name,
-                amount: extendedAmountDifferenceAbs,
-                cycleType: CycleType.INVESTMENT,
-              },
-              extendedAdapter,
-              vesuAdapter
-            );
-            if (extendedStatus) {
-              transactionResults.push({
-                status: extendedStatus,
-                calls: extendedCalls,
-                transactionMetadata: {
-                  ...extendedTransactionMetadata,
-                  transactionType: "DEPOSIT",
-                },
-              });
-            } else {
-              logger.error(
-                `Failed to withdraw from extended - operation returned false status`
-              );
-              return [
-                this.createTransactionResult(
-                  [],
-                  false,
-                  {
-                    from: Protocols.EXTENDED.name,
-                    to: Protocols.VAULT.name,
-                    amount: extendedAmountDifferenceAbs,
-                  },
-                  "NONE",
-                  CycleType.INVESTMENT
-                ),
-              ];
-            }
-          } catch (err) {
-            logger.error(`Failed moving assets from extended to vault: ${err}`);
-            return [
-              this.createTransactionResult(
-                [],
-                false,
-                {
-                  from: Protocols.EXTENDED.name,
-                  to: Protocols.VAULT.name,
-                  amount: extendedAmountDifferenceAbs,
-                },
-                "NONE",
-                CycleType.INVESTMENT
-              ),
-            ];
-          }
-        }
-      }
-
-      // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
-      if (
-        vesuAmountDifferenceAbs.greaterThan(
-          vesuAdapter.minimumVesuMovementAmount
-        )
-      ) {
-        if (vesuAmountDifference.lessThanOrEqualTo(0)) {
-          logger.warn(
-            `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
-          );
-        } else {
-          // Move assets from Extended to Vault (which will then go to Vesu)
-          try {
-            const {
-              calls: vesuCalls,
-              status: vesuStatus,
-              transactionMetadata: vesuTransactionMetadata,
-            } = await this.moveAssets(
-              {
-                to: Protocols.VAULT.name,
-                from: Protocols.EXTENDED.name,
-                amount: vesuAmountDifference,
-                cycleType: CycleType.INVESTMENT,
-              },
-              extendedAdapter,
-              vesuAdapter
-            );
-            if (!vesuStatus) {
-              logger.error(
-                `Failed to move assets to vesu - operation returned false status`
-              );
-              return [
-                this.createTransactionResult(
-                  [],
-                  false,
-                  {
-                    from: Protocols.EXTENDED.name,
-                    to: Protocols.VAULT.name,
-                    amount: vesuAmountDifference,
-                  },
-                  "NONE",
-                  CycleType.INVESTMENT
-                ),
-              ];
-            }
-            transactionResults.push({
-              status: vesuStatus,
-              calls: vesuCalls,
-              transactionMetadata: {
-                ...vesuTransactionMetadata,
-                transactionType: "DEPOSIT",
-              },
-            });
-          } catch (err) {
-            logger.error(`Failed moving assets to vault: ${err}`);
-            return [
-              this.createTransactionResult(
-                [],
-                false,
-                {
-                  from: Protocols.EXTENDED.name,
-                  to: Protocols.VAULT.name,
-                  amount: vesuAmountDifference,
-                },
-                "NONE",
-                CycleType.INVESTMENT
-              ),
-            ];
-          }
-        }
-      }
-      return transactionResults;
-    } catch (err) {
-      logger.error(`Failed moving assets to vesu: ${err}`);
-      return [
-        this.createTransactionResult(
-          [],
-          false,
-          {
-            from: Protocols.EXTENDED.name,
-            to: Protocols.VAULT.name,
-            amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
-          },
-          "NONE",
-          CycleType.INVESTMENT
-        ),
-      ];
-    }
-  }
-
-  /**
-   * Helper method to create transaction result with metadata
-   */
-  private createTransactionResult(
-    calls: Call[],
-    status: boolean,
-    params: { from: string; to: string; amount: Web3Number },
-    transactionType: "DEPOSIT" | "WITHDRAWAL" | "NONE",
-    cycleType: CycleType
-  ): TransactionResult {
-    if (status) {
-      return {
-        calls,
-        status: status,
-        transactionMetadata: {
-          protocolFrom: params.from,
-          protocolTo: params.to,
-          transactionType: transactionType,
-          usdAmount: params.amount.abs().toFixed(),
-          status: "PENDING",
-          cycleType: cycleType,
-        },
-      };
     }
-    return {
-      calls: [],
-      status: false,
-      transactionMetadata: {
-        protocolFrom: "",
-        protocolTo: "",
-        transactionType: "DEPOSIT",
-        usdAmount: "0",
-        status: "FAILED",
-        cycleType: cycleType,
-      },
-    };
-  }
-
-  /**
-   * This method is used to move assets between protocols
-   * @param params - The parameters for the move assets operation
-   * @param extendedAdapter - The extended adapter
-   * @param vesuAdapter - The vesu adapter
-   * @returns The transaction result
-   * If Extended amount is greater than amount of withdrawal from extended, then we need to open a long position
-   * so that the amount of withdrawal from extended is fullfilled
-   */
-  async moveAssets(
-    params: {
-      amount: Web3Number;
-      from: string;
-      to: string;
-      cycleType: CycleType;
-    },
-    extendedAdapter: ExtendedAdapter,
-    vesuAdapter: VesuMultiplyAdapter
-  ): Promise<TransactionResult> {
-    try {
-      // Validate amount is positive before starting operations
-      if (params.amount.lessThanOrEqualTo(0)) {
-        logger.error(
-          `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
-        );
-        return this.createTransactionResult(
-          [],
-          false,
-          params,
-          "NONE",
-          params.cycleType
-        );
-      }
-
-      // Check minimum movement amounts before starting operations
-      // const amountAbs = params.amount.abs();
-      // if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
-      //   if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
-      //     logger.warn(
-      //       `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
-      //     );
-      //     return this.createTransactionResult([], false, params, "NONE", params.cycleType);
-      //   }
-      // }
-      // if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
-      //   if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
-      //     logger.warn(
-      //       `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
-      //     );
-      //     return this.createTransactionResult([], false, params, "NONE", params.cycleType);
-      //   }
-      // }
-
-      const avnuAdapter = await this.getAvnuAdapter();
-      if (!avnuAdapter) {
-        logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return this.createTransactionResult(
-          [],
-          false,
-          params,
-          "NONE",
-          params.cycleType
-        );
-      }
-      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
-      const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
-      const { collateralPrice } = await this.getAssetPrices();
-
-      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 this.createTransactionResult(
-          calls,
-          true,
-          params,
-          "DEPOSIT",
-          params.cycleType
-        );
-      } else if (
-        params.to === Protocols.VAULT.name &&
-        params.from === Protocols.EXTENDED.name
-      ) {
-        const extendedLeverage = calculateExtendedLevergae();
-        const extendedHoldings =
-          await extendedAdapter.getExtendedDepositAmount();
-        if (!extendedHoldings) {
-          logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return this.createTransactionResult(
-            [],
-            false,
-            params,
-            "NONE",
-            params.cycleType
-          );
-        }
-        const extendedHoldingAmount = new Web3Number(
-          extendedHoldings.availableForWithdrawal,
-          USDC_TOKEN_DECIMALS
-        );
-        logger.info(
-          `${
-            VesuExtendedMultiplierStrategy.name
-          }::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
-        );
-        const extendedPositions = await extendedAdapter.getAllOpenPositions();
-        if (!extendedPositions) {
-          logger.error(
-            `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
-          );
-          return this.createTransactionResult(
-            [],
-            false,
-            params,
-            "NONE",
-            params.cycleType
-          );
-        }
-        if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
-          const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
-            Math.ceil(
-              params.amount.abs().minus(extendedHoldingAmount).toNumber()
-            ),
-            USDC_TOKEN_DECIMALS
-          );
-          const positionAmountToClose =
-            await calculatePositionToCloseToWithdrawAmount(
-              extendedHoldings,
-              extendedPositions[0],
-              params.amount
-            );
-          logger.info(
-            `positionAmountToClose: ${positionAmountToClose} this is without leverage`
-          );
-          logger.info(
-            `${
-              VesuExtendedMultiplierStrategy.name
-            }::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
-          );
-          let priceOfBTC;
-          const { ask, bid, status } =
-            await extendedAdapter.fetchOrderBookBTCUSDC();
-          const price = ask.plus(bid).dividedBy(2);
-          if (status) {
-            priceOfBTC = price;
-          } else {
-            logger.error(`error fetching order book btc usdc: ${status}`);
-            priceOfBTC = collateralPrice.price;
-          }
-          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
-          /**
-           * If amount for withdrawal is greater than the amount in extended available for withdrawal,
-           * then we need to open a long position depending on the difference between the two
-           */
-          const openLongPosition = btcAmount
-            .multipliedBy(3)
-            .greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)
-            ? await extendedAdapter.createOrder(
-                extendedLeverage.toString(),
-                btcAmount.toNumber(),
-                OrderSide.BUY
-              )
-            : await extendedAdapter.createOrder(
-                extendedLeverage.toString(),
-                0.000034, // just in case amount falls short then we need to create a withdrawal
-                OrderSide.BUY
-              );
-          if (!openLongPosition) {
-            logger.error(`error opening long position: ${openLongPosition}`);
-          }
-          const updatedHoldings =
-            await extendedAdapter.getExtendedDepositAmount();
-          if (
-            !updatedHoldings ||
-            new Web3Number(
-              updatedHoldings.availableForWithdrawal,
-              USDC_TOKEN_DECIMALS
-            ).lessThan(params.amount.abs())
-          ) {
-            logger.error(
-              `Insufficient balance after opening position. Available: ${
-                updatedHoldings?.availableForWithdrawal
-              }, Needed: ${params.amount.abs()}`
-            );
-            return this.createTransactionResult(
-              [],
-              false,
-              params,
-              "NONE",
-              params.cycleType
-            );
-          }
-        }
-        const {
-          status: withdrawalFromExtendedStatus,
-          receivedTxnHash: withdrawalFromExtendedTxnHash,
-        } = await extendedAdapter.withdrawFromExtended(params.amount);
-        /**
-         * This logic needs fixing
-         */
-        logger.info(
-          `withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`
-        );
-        if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
-          /**
-           * We need to move assets from my wallet back to vault contract
-           */
-          const extendedHoldings =
-            await extendedAdapter.getExtendedDepositAmount();
-          logger.info(
-            `extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`
-          );
-          await new Promise((resolve) => setTimeout(resolve, 5000));
-          const { calls, status } = await this.moveAssetsToVaultAllocator(
-            params.amount,
-            extendedAdapter
-          );
-          if (calls.length > 0 && status) {
-            return this.createTransactionResult(
-              calls,
-              true,
-              params,
-              "WITHDRAWAL",
-              params.cycleType
-            );
-          } else {
-            /**
-             * This is a fallback scenario, where the funds were withdrawn from extended, but didn't get transferred to the wallet
-             * We need to return a successful transaction result, but with no calls
-             * Db update will be handled by the risk engine for this specific case
-             */
-            return this.createTransactionResult(
-              [],
-              true,
-              params,
-              "WITHDRAWAL",
-              params.cycleType
-            );
-          }
-        } else if (
-          withdrawalFromExtendedStatus &&
-          !withdrawalFromExtendedTxnHash
-        ) {
-          logger.error(
-            "withdrawal from extended successful, but funds didn't get transferred to the wallet"
-          );
-          return this.createTransactionResult(
-            [],
-            true,
-            params,
-            "WITHDRAWAL",
-            params.cycleType
-          );
-        } else {
-          logger.error("withdrawal from extended failed");
-          return this.createTransactionResult(
-            [],
-            false,
-            params,
-            "NONE",
-            params.cycleType
-          );
-        }
-      } else if (
-        params.to === Protocols.VAULT.name &&
-        params.from === Protocols.VESU.name
-      ) {
-        const isPriceDifferenceBetweenAvnuAndExtended =
-          await this.checkPriceDifferenceBetweenAvnuAndExtended(
-            extendedAdapter,
-            vesuAdapter,
-            avnuAdapter,
-            PositionTypeAvnuExtended.CLOSE
-          );
-        if (
-          !isPriceDifferenceBetweenAvnuAndExtended &&
-          params.cycleType === CycleType.WITHDRAWAL
-        ) {
-          logger.warn(
-            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
-          );
-          return this.createTransactionResult(
-            [],
-            false,
-            params,
-            "NONE",
-            params.cycleType
-          );
-        }
-        //withdraw from vesu
-        const vesuAmountInBTC = new Web3Number(
-          params.amount
-            .dividedBy(collateralPrice.price)
-            .toFixed(WBTC_TOKEN_DECIMALS),
-          collateralToken.decimals
-        );
-        const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
-        const calls = [];
-        const proofGroups = proofsInfo.proofs;
-        const call = this.getManageCall(
-          proofGroups,
-          await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
-        );
-        calls.push(call);
-        const swapProofsInfo = avnuAdapter.getProofs(
-          false,
-          this.getMerkleTree()
-        );
-        const swapProofGroups = swapProofsInfo.proofs;
-        const swapCall = this.getManageCall(
-          swapProofGroups,
-          await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
-        );
-        calls.push(swapCall);
-        return this.createTransactionResult(
-          calls,
-          true,
-          params,
-          "WITHDRAWAL",
-          params.cycleType
-        );
-      } else if (
-        params.to === Protocols.EXTENDED.name &&
-        params.from === Protocols.VESU.name
-      ) {
-        const isPriceDifferenceBetweenAvnuAndExtended =
-          await this.checkPriceDifferenceBetweenAvnuAndExtended(
-            extendedAdapter,
-            vesuAdapter,
-            avnuAdapter,
-            PositionTypeAvnuExtended.CLOSE
-          );
-        if (!isPriceDifferenceBetweenAvnuAndExtended) {
-          logger.warn(
-            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
-          );
-          return this.createTransactionResult(
-            [],
-            false,
-            params,
-            "NONE",
-            params.cycleType
-          );
-        }
-        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 this.createTransactionResult(
-          calls,
-          true,
-          params,
-          "DEPOSIT",
-          params.cycleType
-        );
-      }
-      logger.error(
-        `Unsupported assets movement: ${params.from} to ${params.to}`
-      );
-      return this.createTransactionResult(
-        [],
-        false,
-        params,
-        "NONE",
-        params.cycleType
-      );
-    } catch (err) {
-      logger.error(`error moving assets: ${err}`);
-      return this.createTransactionResult(
-        [],
-        false,
-        params,
-        "NONE",
-        params.cycleType
+    if (!extendedAdapter.adapter || !(extendedAdapter.adapter as ExtendedAdapter).client) {
+      throw new Error(
+        `${this.getTag()} Extended adapter client not initialized.`
       );
     }
+    return extendedAdapter.adapter as ExtendedAdapter;
   }
 
-  async handleDeposit(): Promise<TransactionResult> {
-    try {
-      /**
-       * Just a demo function, not used in the risk engine
-       */
-      return this.createTransactionResult(
-        [],
-        false,
-        {
-          from: Protocols.VAULT.name,
-          to: Protocols.VAULT.name,
-          amount: new Web3Number(0, 0),
-        },
-        "NONE",
-        CycleType.INVESTMENT
-      );
-    } catch (err) {
-      logger.error(`error handling deposit: ${err}`);
-      return this.createTransactionResult(
-        [],
-        false,
-        {
-          from: Protocols.VAULT.name,
-          to: Protocols.VAULT.name,
-          amount: new Web3Number(0, 0),
-        },
-        "NONE",
-        CycleType.INVESTMENT
+  async getUsdcToUsdceAdapter(): Promise<UsdcToUsdceAdapter> {
+    const usdcToUsdceAdapter = this.metadata.additionalInfo.adapters.find(
+      (adapter) => adapter.adapter.name === UsdcToUsdceAdapter.name,
+    );
+    if (!usdcToUsdceAdapter) {
+      throw new Error(
+        `${this.getTag()} UsdcToUsdce adapter not configured in metadata.`
       );
     }
+    return usdcToUsdceAdapter.adapter as UsdcToUsdceAdapter;
   }
 
   /**
-   * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
-   * @param extendedAdapter - the extended adapter
-   * @param vesuAdapter - the vesu adapter
-   * @param avnuAdapter - the avnu adapter
-   * @param positionType - the position type (open or close)
-   * @returns true if the price difference is within the acceptable range, false otherwise
+   * 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 checkPriceDifferenceBetweenAvnuAndExtended(
-    extendedAdapter: ExtendedAdapter,
-    vesuAdapter: VesuMultiplyAdapter,
-    avnuAdapter: AvnuAdapter,
-    positionType: PositionTypeAvnuExtended
-  ): Promise<boolean> {
-    const { ask, bid } = await extendedAdapter.fetchOrderBookBTCUSDC();
-    const price = ask.plus(bid).dividedBy(2);
-    const btcToken = vesuAdapter.config.supportedPositions[0].asset;
-    const btcPriceAvnu = await avnuAdapter.getPriceOfToken(
-      btcToken.address.toString()
-    );
+  async createExecutionService(opts?: {
+    onExecutionEvent?: ExecutionCallback;
+    extendedAcceptableSlippageBps?: number;
+    maxPriceDivergenceBps?: number;
+  }): Promise<ExecutionService> {
+    const [
+      vesuAdapter,
+      vesuModifyPositionAdapter,
+      usdceTransferAdapter,
+      extendedAdapter,
+      avnuAdapter,
+      usdcToUsdceAdapter,
+    ] =
+      await Promise.all([
+        this.getVesuAdapter(),
+        this.getVesuModifyPositionAdapter(),
+        this.getUsdceTransferAdapter(),
+        this.getExtendedAdapter(),
+        this.getAvnuAdapter(),
+        this.getUsdcToUsdceAdapter(),
+      ]);
+
+    const executionConfig: ExecutionConfig = {
+      networkConfig: this.config,
+      pricer: this.pricer,
+      vesuAdapter,
+      vesuModifyPositionAdapter,
+      extendedAdapter,
+      avnuAdapter,
+      usdcToUsdceAdapter,
+      vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
+      walletAddress: this.metadata.additionalInfo.walletAddress,
+      usdceTransferAdapter,
+      wbtcToken: this.wbtcToken,
+      usdcToken: this.usdcToken,
+      usdceToken: this.usdceToken,
+      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 (!btcPriceAvnu) {
-      logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
-      return false;
-    }
-    logger.info(`price: ${price}`);
-    logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
-    const priceDifference = new Web3Number(
-      price.minus(btcPriceAvnu).toFixed(2),
-      0
-    );
-    logger.info(`priceDifference: ${priceDifference}`);
-    if (priceDifference.isNegative()) {
-      return false;
-    }
-    if (positionType === PositionTypeAvnuExtended.OPEN) {
-      logger.info(
-        `price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${
-          avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen
-        }`
-      );
-      const result = priceDifference.greaterThanOrEqualTo(
-        avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen
-      ); // 500 for now
-      logger.info(`result: ${result}`);
-      return result;
-    } else {
-      logger.info(
-        `price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${
-          avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing
-        }`
-      );
-      const result = priceDifference.lessThanOrEqualTo(
-        avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing
-      ); // 1000 for now
-      logger.info(`result: ${result}`);
-      return result;
-    }
+    return new ExecutionService(executionConfig);
   }
 
   /**
-   * Handle the withdrawal of assets from the vault
-   * @param amount - the amount to withdraw in USDC
-   * @returns the calls to be executed and the status of the calls generated along with the metadata for the calls
+   * 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 handleWithdraw(amount: Web3Number): Promise<TransactionResult[]> {
-    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,
-        });
-        calls.push(withdrawCall);
-        return [
-          this.createTransactionResult(
-            calls,
-            true,
-            {
-              from: Protocols.VAULT.name,
-              to: Protocols.NONE.name,
-              amount: amount,
-            },
-            "WITHDRAWAL",
-            CycleType.WITHDRAWAL
-          ),
-        ];
-      }
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
-        status = false;
-        logger.error(
-          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
-        );
-        return [
-          this.createTransactionResult(
-            calls,
-            status,
-            {
-              from: Protocols.VAULT.name,
-              to: Protocols.NONE.name,
-              amount: amount,
-            },
-            "NONE",
-            CycleType.WITHDRAWAL
-          ),
-        ];
-      }
-      let transactionResults: TransactionResult[] = [];
-      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 [
-          this.createTransactionResult(
-            calls,
-            status,
-            {
-              from: Protocols.VAULT.name,
-              to: Protocols.NONE.name,
-              amount: amount,
-            },
-            "NONE",
-            CycleType.WITHDRAWAL
-          ),
-        ];
-      }
-      const amountDistributionForWithdrawal =
-        await calculateAmountDistributionForWithdrawal(
-          usdcBalanceDifference,
-          collateralPrice.price,
-          collateralTokenAmount,
-          extendedPositon
-        );
-      if (!amountDistributionForWithdrawal) {
-        status = false;
-        logger.error(
-          `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
-        );
-        return [
-          this.createTransactionResult(
-            calls,
-            status,
-            {
-              from: Protocols.VAULT.name,
-              to: Protocols.NONE.name,
-              amount: amount,
-            },
-            "NONE",
-            CycleType.WITHDRAWAL
-          ),
-        ];
-      }
-      const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
-
-      if (status && vesu_amount.greaterThan(0)) {
-        const {
-          calls: vesuCalls,
-          status: vesuStatus,
-          transactionMetadata: vesuTransactionMetadata,
-        } = await this.moveAssets(
-          {
-            amount: vesu_amount,
-            from: Protocols.VESU.name,
-            to: Protocols.VAULT.name,
-            cycleType: CycleType.WITHDRAWAL,
-          },
-          extendedAdapter,
-          vesuAdapter
-        );
-        status = vesuStatus;
-        transactionResults.push({
-          status: vesuStatus,
-          calls: vesuCalls,
-          transactionMetadata: vesuTransactionMetadata,
-        });
-      }
-      if (status && extended_amount.greaterThan(0)) {
-        const {
-          calls: extendedCalls,
-          status: extendedStatus,
-          transactionMetadata: extendedTransactionMetadata,
-        } = await this.moveAssets(
-          {
-            amount: extended_amount,
-            from: Protocols.EXTENDED.name,
-            to: Protocols.VAULT.name,
-            cycleType: CycleType.WITHDRAWAL,
-          },
-          extendedAdapter,
-          vesuAdapter
-        );
-        status = extendedStatus;
-        if (status) {
-          transactionResults.push({
-            status: extendedStatus,
-            calls: extendedCalls,
-            transactionMetadata: extendedTransactionMetadata,
-          });
-        } else {
-          logger.error(
-            "error moving assets to vault: extendedStatus: ${extendedStatus}"
-          );
-          return [
-            this.createTransactionResult(
-              [],
-              status,
-              {
-                from: Protocols.VAULT.name,
-                to: Protocols.NONE.name,
-                amount: amount,
-              },
-              "NONE",
-              CycleType.WITHDRAWAL
-            ),
-          ];
-        }
-      }
-      const withdrawCall = await this.getBringLiquidityCall({
-        amount: amount,
-      });
-      logger.info("withdraw call", withdrawCall);
-      transactionResults.push({
-        status: status,
-        calls: [withdrawCall],
-        transactionMetadata: {
-          protocolFrom: Protocols.VAULT.name,
-          protocolTo: Protocols.NONE.name,
-          transactionType: "WITHDRAWAL",
-          usdAmount: amount.toFixed(),
-          status: "PENDING",
-          cycleType: CycleType.WITHDRAWAL,
-        },
-      });
-      return transactionResults;
-    } catch (err) {
-      logger.error(`error handling withdrawal: ${err}`);
-      return [
-        this.createTransactionResult(
-          [],
-          false,
-          {
-            from: Protocols.VAULT.name,
-            to: Protocols.NONE.name,
-            amount: amount,
-          },
-          "NONE",
-          CycleType.WITHDRAWAL
-        ),
-      ];
-    }
-  }
-
   async getAUM(): Promise<{
     net: SingleTokenInfo;
     prevAum: Web3Number;
@@ -1760,10 +323,14 @@ export class VesuExtendedMultiplierStrategy<
   }> {
     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.filter((position) => {
+          return position.tokenInfo.address !== this.usdceToken.address;
+        });
+        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) {
@@ -1774,6 +341,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(),
@@ -1804,140 +381,101 @@ export class VesuExtendedMultiplierStrategy<
     };
   }
 
-  async processTransactionDataFromSDK(
-    txnData: TransactionResult<any>[]
-  ): Promise<{
-    callsToBeExecutedFinal: Call[];
-    txnMetadata: TransactionMetadata[];
-  } | null> {
-    try {
-      const txnsToBeExecuted = txnData.filter((txn) => {
-        return (
-          txn.transactionMetadata.transactionType !== "NONE" &&
-          txn.transactionMetadata.protocolFrom !== "" &&
-          txn.transactionMetadata.protocolTo !== ""
-        );
-      });
-      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap(
-        (txn) => txn.calls
-      );
-      const txnMetadata = txnsToBeExecuted.map(
-        (txn) => txn.transactionMetadata
-      );
-      return { callsToBeExecutedFinal, txnMetadata };
-    } catch (err) {
-      logger.error(`error processing transaction data from SDK: ${err}`);
-      return null;
-    }
-  }
-
-  async processTransactionMetadata(
-    txnMetadata: TransactionMetadata[],
-    extendedIntentFulfilled: boolean
-  ): Promise<TransactionMetadata[] | null> {
-    try {
-      const txnMetadataNew = txnMetadata.map((txn) => {
-        const isExtendedProtocol =
-          txn.protocolFrom === Protocols.EXTENDED.name ||
-          txn.protocolTo === Protocols.EXTENDED.name;
-        // Only update status for extended protocol transactions since thsoe only cause delays
-        if (isExtendedProtocol) {
-          txn.status = extendedIntentFulfilled ? "COMPLETED" : "PENDING";
-        } else {
-          txn.status = "COMPLETED";
-        }
-        return txn;
-      });
-      return txnMetadataNew;
-    } catch (err) {
-      logger.error(`error processing transaction data from SDK: ${err}`);
-      return null;
-    }
-  }
 
+  /**
+   * 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.getVesuAdapter();
+    const vesuAdapter = await this.getVesuModifyPositionAdapter();
     const extendedAdapter = await this.getExtendedAdapter();
-    if (!vesuAdapter || !extendedAdapter) {
-      return new Web3Number(0, 0);
-    }
     const extendedFundingRate = new Web3Number(
       (await extendedAdapter.getNetAPY()).toFixed(4),
-      0
+      0,
     );
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
     if (!extendedPositions || extendedPositions.length === 0) {
-      logger.info(`no extended positions found`);
+      logger.warn(`${this.getTag()} getMaxBorrowableAmount: no extended positions found`);
       return new Web3Number(0, 0);
     }
     const extendePositionSizeUSD = new Web3Number(
       extendedPositions[0].value || 0,
-      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
+      USDC_TOKEN_DECIMALS,
     );
     const vesuDebtSizeUSD = new Web3Number(
       vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
-      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 vesuMaxBorrowableAmount =
-      await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(
+    const vesuMaxBorrowableResult =
+      await vesuAdapter._vesuAdapter.getMaxBorrowableByInterestRate(
         this.config,
         vesuAdapter.config.debt,
-        maxBorrowApy.toNumber()
+        maxBorrowApy.toNumber(),
       );
     return new Web3Number(
-      vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS),
-      USDC_TOKEN_DECIMALS
+      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.getVesuAdapter();
+    const vesuAdapter = await this.getVesuModifyPositionAdapter();
     const extendedAdapter = await this.getExtendedAdapter();
-    if (!vesuAdapter || !extendedAdapter) {
-      return [0, 0];
-    }
     const vesuPositions = await vesuAdapter.getPositions();
     const vesuCollateralSizeUSD = new Web3Number(
       vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
-      0
+      0,
     );
     const vesuDebtSizeUSD = new Web3Number(
       vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
-      0
+      0,
     );
     const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
-    logger.info(`actualLtv: ${actualLtv.toNumber()}`);
+    logger.debug(`${this.getTag()} getVesuHealthFactors: actualLtv=${actualLtv.toNumber()}`);
     const maxLtv = new Web3Number(
-      await vesuAdapter.vesuAdapter.getLTVConfig(this.config),
-      4
+      await vesuAdapter._vesuAdapter.getLTVConfig(this.config),
+      4,
     );
     const healthFactor = new Web3Number(
       maxLtv.dividedBy(actualLtv).toFixed(4),
-      4
+      4,
     );
-    logger.info(`healthFactor: ${healthFactor.toNumber()}`);
+    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
+      4,
     );
-    logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
+    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 }[];
@@ -1952,23 +490,14 @@ export class VesuExtendedMultiplierStrategy<
       }
     }
     const extendedAdapter = await this.getExtendedAdapter();
-    if (!extendedAdapter) {
-      return {
-        net: 0,
-        splits: [],
-      };
-    }
     let vesuPositions = allPositions.filter(
-      (item) => item.protocol === Protocols.VESU
+      (item) => item.protocol === Protocols.VESU,
     );
     vesuPositions.map((item) => {
       item.apy.apy = item.apy.apy * 0.1;
     });
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
-    const usdcToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "USDC"
-    );
-    if (!extendedPositions || !usdcToken) {
+    if (!extendedPositions || !this.usdcToken) {
       return {
         net: 0,
         splits: [],
@@ -1981,19 +510,19 @@ export class VesuExtendedMultiplierStrategy<
     const totalHoldingsUSDValue =
       allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) +
       Number(extendedEquity);
-    console.log(totalHoldingsUSDValue);
     const extendedPositionSizeMultipliedByApy =
       Number(extendedPosition.value) * extendedApy;
     let weightedAPYs =
       allPositions.reduce(
         (acc, curr) => acc + curr.apy.apy * curr.usdValue,
-        0
+        0,
       ) + extendedPositionSizeMultipliedByApy;
-    console.log(weightedAPYs);
     const netAPY = weightedAPYs / totalHoldingsUSDValue;
-    console.log(netAPY);
+    logger.debug(
+      `${this.getTag()} netAPY: holdingsUsd=${totalHoldingsUSDValue}, weightedApy=${weightedAPYs}, net=${netAPY}`,
+    );
     allPositions.push({
-      tokenInfo: usdcToken,
+      tokenInfo: this.usdcToken,
       amount: new Web3Number(extendedPosition.size, 0),
       usdValue: Number(extendedEquity),
       apy: { apy: extendedApy, type: APYType.BASE },
@@ -2009,6 +538,10 @@ export class VesuExtendedMultiplierStrategy<
     };
   }
 
+  /**
+   * Fetches the operator wallet's current holdings for USDC.e, USDC, and WBTC,
+   * returning each token's balance and USD value.
+   */
   async getWalletHoldings(): Promise<
     {
       tokenInfo: TokenInfo;
@@ -2016,62 +549,47 @@ export class VesuExtendedMultiplierStrategy<
       usdValue: number;
     }[]
   > {
-    const usdceToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "USDCe"
-    );
-    const wbtcToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "WBTC"
-    );
-    const usdcToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "USDC"
-    );
-    if (!usdceToken || !wbtcToken || !usdcToken) {
+    if (!this.usdceToken || !this.wbtcToken || !this.usdcToken) {
       return [];
     }
     const walletAddress = this.metadata.additionalInfo.walletAddress;
     const usdceWalletBalance = await new ERC20(this.config).balanceOf(
-      usdceToken.address,
+      this.usdceToken.address,
       walletAddress,
-      usdceToken.decimals
+      this.usdceToken.decimals,
     );
     const usdcWalletBalance = await new ERC20(this.config).balanceOf(
-      usdcToken.address,
-      walletAddress,
-      usdcToken.decimals
-    );
-    const wbtcWalletBalance = await new ERC20(this.config).balanceOf(
-      wbtcToken.address,
+      this.usdcToken.address,
       walletAddress,
-      wbtcToken.decimals
+      this.usdcToken.decimals,
     );
-    const price = await this.pricer.getPrice(usdceToken.symbol);
-    const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
+    const price = await this.pricer.getPrice(this.usdceToken.symbol);
+    const wbtcPrice = await this.pricer.getPrice(this.wbtcToken.symbol);
     const usdceUsdValue =
-      Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+      Number(usdceWalletBalance.toFixed(this.usdceToken.decimals)) *
+      price.price;
     const usdcUsdValue =
-      Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
-    const wbtcUsdValue =
-      Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+      Number(usdcWalletBalance.toFixed(this.usdcToken.decimals)) * price.price;
     return [
       {
-        tokenInfo: usdceToken,
+        tokenInfo: this.usdceToken,
         amount: usdceWalletBalance,
         usdValue: usdceUsdValue,
       },
       {
-        tokenInfo: usdcToken,
+        tokenInfo: this.usdcToken,
         amount: usdcWalletBalance,
         usdValue: usdcUsdValue,
-      },
-      {
-        tokenInfo: wbtcToken,
-        amount: wbtcWalletBalance,
-        usdValue: wbtcUsdValue,
-      },
+      }
     ];
   }
 }
 
+/**
+ * Configures all adapters (Vesu, Extended, Avnu, UsdcToUsdce, 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,
   underlyingSymbol: string,
@@ -2084,15 +602,18 @@ function getLooperSettings(
   minimumVesuMovementAmount: number,
   minimumExtendedRetriesDelayForOrderStatus: number,
   minimumExtendedPriceDifferenceForSwapOpen: number,
-  maximumExtendedPriceDifferenceForSwapClosing: number
+  maximumExtendedPriceDifferenceForSwapClosing: number,
 ) {
   vaultSettings.leafAdapters = [];
 
   const wbtcToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === lstSymbol
+    (token) => token.symbol === lstSymbol,
   )!;
   const usdcToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === underlyingSymbol
+    (token) => token.symbol === underlyingSymbol,
+  )!;
+  const usdceToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === "USDC.e",
   )!;
 
   const baseAdapterConfig: BaseAdapterConfig = {
@@ -2119,9 +640,19 @@ function getLooperSettings(
       maximumExtendedPriceDifferenceForSwapClosing,
   });
 
+  const usdcToUsdceAdapter = new UsdcToUsdceAdapter({
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: usdcToken, isDebt: true },
+      { asset: usdceToken, isDebt: false },
+    ],
+  });
+
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
-    supportedPositions: [{ asset: usdcToken, isDebt: true }],
+    supportedPositions: [
+      { asset: usdceToken, isDebt: false },
+    ],
     vaultIdExtended: vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
     extendedBackendWriteUrl: extendedBackendWriteUrl,
@@ -2140,6 +671,7 @@ function getLooperSettings(
     poolId: pool1,
     collateral: wbtcToken,
     debt: usdcToken,
+    marginToken: usdcToken,
     targetHealthFactor: vaultSettings.targetHealthFactor,
     minHealthFactor: vaultSettings.minHealthFactor,
     quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
@@ -2151,8 +683,28 @@ function getLooperSettings(
     minimumVesuMovementAmount: minimumVesuMovementAmount ?? 5, //5 usdc
   });
 
-  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+  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 },
+    ],
+  });
+
+  // Transfers USDC between the vault allocator (fromAddress) and the operator wallet (toAddress)
+  const usdceTransferAdapter = new TokenTransferAdapter({
+    ...baseAdapterConfig,
+    baseToken: usdceToken,
+    supportedPositions: [{ asset: usdceToken, isDebt: false }],
+    fromAddress: vaultSettings.vaultAllocator,
+    toAddress: ContractAddr.from(vaultSettings.walletAddress),
   });
 
   vaultSettings.adapters.push({
@@ -2161,8 +713,18 @@ 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: `${usdceTransferAdapter.name}_${usdceToken.symbol}`,
+    adapter: usdceTransferAdapter,
+  });
+
+  vaultSettings.adapters.push({
+    id: `${usdcToUsdceAdapter.name}_${usdceToken.symbol}_${usdcToken.symbol}`,
+    adapter: usdcToUsdceAdapter,
   });
 
   vaultSettings.adapters.push({
@@ -2185,26 +747,29 @@ function getLooperSettings(
 
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
   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(() => usdcToUsdceAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => usdcToUsdceAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => usdceTransferAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => usdceTransferAdapter.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;
 }
@@ -2215,7 +780,7 @@ function getDescription(tokenSymbol: string, underlyingSymbol: string) {
 
 export default function VaultDescription(
   lstSymbol: string,
-  underlyingSymbol: string
+  underlyingSymbol: string,
 ) {
   const containerStyle = {
     maxWidth: "800px",
@@ -2299,36 +864,37 @@ export default function VaultDescription(
 
 const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
   vaultAddress: ContractAddr.from(
-    "0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"
+    "0x772d6cf5038c18ff5ab89f8945017bbf4d2c6959891339975c70a4f74ac6c8e",
   ),
   manager: ContractAddr.from(
-    "0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"
+    "0x3340c9d7231838e2dccff72b9004f1598a74e65c74b954f07fe1ea19d04a625",
   ),
   vaultAllocator: ContractAddr.from(
-    "0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"
+    "0x537353b35eee5ca2d9a45eb646977baddd4e89ce870a231dcada79884117292",
   ),
   redeemRequestNFT: ContractAddr.from(
-    "0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"
+    "0x6117d1a8c72c0457948083757e1a17ee8c0833b969d5c959b629e5f8feb56ec",
   ),
   aumOracle: ContractAddr.from(
-    "0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"
+    "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")!,
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")!,
   ],
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
-  walletAddress: WALLET_ADDRESS,
+  walletAddress: '0x024b563C1C7d41B32BF4EFB9F38828508a65Be2d6e25268E9f63F22C5e9E51c5',
 };
 
 export const VesuExtendedTestStrategies = (
@@ -2339,7 +905,7 @@ export const VesuExtendedTestStrategies = (
   minimumVesuMovementAmount: number,
   minimumExtendedRetriesDelayForOrderStatus: number,
   minimumExtendedPriceDifferenceForSwapOpen: number,
-  maximumExtendedPriceDifferenceForSwapClosing: number
+  maximumExtendedPriceDifferenceForSwapClosing: number,
 ): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
   return [
     getStrategySettingsVesuExtended(
@@ -2355,11 +921,15 @@ export const VesuExtendedTestStrategies = (
       minimumVesuMovementAmount,
       minimumExtendedRetriesDelayForOrderStatus,
       minimumExtendedPriceDifferenceForSwapOpen,
-      maximumExtendedPriceDifferenceForSwapClosing
+      maximumExtendedPriceDifferenceForSwapClosing,
     ),
   ];
 };
 
+/**
+ * Constructs a complete IStrategyMetadata object for a Vesu-Extended strategy,
+ * including adapter wiring, risk configuration, FAQ, and UI description.
+ */
 function getStrategySettingsVesuExtended(
   lstSymbol: string,
   underlyingSymbol: string,
@@ -2373,17 +943,22 @@ function getStrategySettingsVesuExtended(
   minimumVesuMovementAmount: number,
   minimumExtendedRetriesDelayForOrderStatus: number,
   minimumExtendedPriceDifferenceForSwapOpen: number,
-  maximumExtendedPriceDifferenceForSwapClosing: number
+  maximumExtendedPriceDifferenceForSwapClosing: number,
 ): IStrategyMetadata<VesuExtendedStrategySettings> {
   return {
+    id: `extended_${underlyingSymbol.toLowerCase()}_test`,
     name: `Extended Test ${underlyingSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
     address: addresses.vaultAddress,
     launchBlock: 0,
     type: "Other",
+    vaultType: {
+      type: VaultType.DELTA_NEUTRAL,
+      description: "Delta Neutral strategy using extended position on Vesu"
+    },
     depositTokens: [
       Global.getDefaultTokens().find(
-        (token) => token.symbol === underlyingSymbol
+        (token) => token.symbol === 'WBTC',
       )!,
     ],
     additionalInfo: getLooperSettings(
@@ -2398,7 +973,7 @@ function getStrategySettingsVesuExtended(
       minimumVesuMovementAmount,
       minimumExtendedRetriesDelayForOrderStatus,
       minimumExtendedPriceDifferenceForSwapOpen,
-      maximumExtendedPriceDifferenceForSwapClosing
+      maximumExtendedPriceDifferenceForSwapClosing,
     ),
     risk: {
       riskFactor: _riskFactor,
@@ -2409,7 +984,6 @@ function getStrategySettingsVesuExtended(
     },
     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),
@@ -2417,5 +991,27 @@ function getStrategySettingsVesuExtended(
     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,
   };
 }