@strkfarm/sdk 2.0.0-dev.34 → 2.0.0-dev.35

package/src/strategies/usdc-boosted-strategy.tsx

@@ -0,0 +1,693 @@
+import {
+  getMainnetConfig,
+  IConfig,
+  IStrategyMetadata,
+  Protocols,
+  TokenInfo,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  VaultType,
+  RedemptionInfo,
+  StrategyTag,
+  VaultPosition,
+} from "@/interfaces";
+import {
+  AUMTypes,
+  getContractDetails,
+  UNIVERSAL_MANAGE_IDS,
+  UniversalStrategySettings,
+} from "./universal-strategy";
+import { PricerBase } from "@/modules/pricerBase";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Global } from "@/global";
+import {
+  APYType,
+  AvnuAdapter,
+  AvnuAdapterConfig,
+  BaseAdapterConfig,
+  CommonAdapter,
+  ManageCall,
+  PositionInfo,
+  TokenTransferAdapter,
+  VesuModifyPositionAdapter,
+} from "./universal-adapters";
+import { SvkTrovesAdapter } from "./universal-adapters/svk-troves-adapter";
+import { VesuPools } from "./universal-adapters/vesu-adapter";
+import {
+  AVNU_EXCHANGE,
+  AVNU_QUOTE_URL,
+} from "./universal-adapters/adapter-utils";
+import { PricerFromApi, ERC20 } from "@/modules";
+import { assert, logger } from "@/utils";
+import { SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { SVKStrategy } from "./svk-strategy";
+import { BlockIdentifier, Call, uint256 } from "starknet";
+import { AdapterOptimizer } from "./universal-adapters/adapter-optimizer";
+
+export interface USDCBoostedStrategySettings extends UniversalStrategySettings {
+  vesuPoolId: ContractAddr;
+  collateralToken: TokenInfo; // USDC
+  debtToken: TokenInfo; // STRK
+  maxLTV: number; // e.g. 0.66
+  targetLTV: number;
+  hyperxSTRKVaultAddress: ContractAddr;
+}
+
+export class USDCBoostedStrategy<
+  S extends USDCBoostedStrategySettings,
+> extends SVKStrategy<S> {
+  constructor(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<S>,
+  ) {
+    super(config, pricer, metadata);
+
+    this.metadata.additionalInfo.adapters.forEach((adapter) => {
+      adapter.adapter.config.networkConfig = this.config;
+      adapter.adapter.config.pricer = this.pricer;
+      if ((adapter.adapter as any)._vesuAdapter) {
+        (adapter.adapter as any)._vesuAdapter.networkConfig = this.config;
+        (adapter.adapter as any)._vesuAdapter.pricer = this.pricer;
+      }
+    });
+  }
+
+  getTag(): string {
+    return `${USDCBoostedStrategy.name}:${this.metadata.name}`;
+  }
+
+  private getAdapterById<T>(id: string): T {
+    const entry = this.metadata.additionalInfo.adapters.find(
+      (a) => a.id === id,
+    );
+    if (!entry) {
+      throw new Error(
+        `${this.getTag()}::getAdapterById: adapter not found for id "${id}"`,
+      );
+    }
+    return entry.adapter as T;
+  }
+
+  async getVesuModifyPositionCall(params: {
+    isDeposit: boolean;
+    leg1DepositAmount: Web3Number;
+    debtAmount?: Web3Number;
+  }): Promise<Call> {
+    logger.verbose(
+      `${this.getTag()}::getVesuModifyPositionCall isDeposit=${params.isDeposit}, amount=${params.leg1DepositAmount}, debtAmount=${params.debtAmount?.toNumber()}`,
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById<VesuModifyPositionAdapter>("vesu_usdc_strk"),
+      params.isDeposit,
+      params.leg1DepositAmount,
+      params.debtAmount ? { debtAmount: params.debtAmount } : undefined,
+    );
+  }
+
+  async getVesuPositions(): Promise<VaultPosition[]> {
+    const positions =
+      await this.getAdapterById<VesuModifyPositionAdapter>(
+        "vesu_usdc_strk",
+      ).getPositions();
+    return positions.map((p) => ({
+      amount: p.amount,
+      usdValue: p.usdValue,
+      remarks: p.remarks ?? "",
+      token: p.tokenInfo,
+      protocol: p.protocol,
+    }));
+  }
+
+  async getVesuHealthFactor(
+    blockNumber: BlockIdentifier = "latest",
+  ): Promise<number> {
+    const vesuAdapter =
+      this.getAdapterById<VesuModifyPositionAdapter>("vesu_usdc_strk");
+    return await vesuAdapter._vesuAdapter.getHealthFactor(blockNumber);
+  }
+
+  // TODO: will have to still modify for instant withdrawals as of now
+  async getModifyHyperPositionCall(params: {
+    isDeposit: boolean;
+    amount: Web3Number;
+  }): Promise<Call> {
+    logger.verbose(
+      `${this.getTag()}::getModifyHyperPositionCall isDeposit=${params.isDeposit}, amount=${params.amount}`,
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById<SvkTrovesAdapter>("hyper_xstrk"),
+      params.isDeposit,
+      params.amount,
+    );
+  }
+
+  async getAvnuSwapCall(params: {
+    isDeposit: boolean;
+    amount: Web3Number;
+  }): Promise<Call> {
+    logger.verbose(
+      `${this.getTag()}::getAvnuSwapCall isDeposit=${params.isDeposit}, amount=${params.amount}`,
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById<AvnuAdapter>("avnu_strk_xstrk"),
+      params.isDeposit,
+      params.amount,
+    );
+  }
+
+  /**
+   * Returns the USDC balance sitting idle inside the vault contract itself.
+   * This balance can offset the required liquidity during withdrawal processing.
+   */
+  async getUnusedBalanceVault(): Promise<Web3Number> {
+    const collateralToken = this.metadata.additionalInfo.collateralToken;
+    return new ERC20(this.config).balanceOf(
+      collateralToken.address,
+      this.metadata.additionalInfo.vaultAddress,
+      collateralToken.decimals,
+    );
+  }
+
+  /**
+   * Returns the current STRK balance sitting unused in the vault allocator.
+   * This covers STRK from prior borrow cycles that hasn't been swapped yet.
+   */
+  // Technically we can use this or we can even use the avnu-adapter to get the unused debt
+  async getUnusedDebt(): Promise<Web3Number> {
+    const debtToken = this.metadata.additionalInfo.debtToken;
+    return new ERC20(this.config).balanceOf(
+      debtToken.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      debtToken.decimals,
+    );
+  }
+
+  /**
+   * Returns the xSTRK balance sitting in the vault allocator.
+   * This is non-zero when the previous cycle's request_redeem on the HyperPosition
+   * has been settled — the redeemed xSTRK lands here and is ready to be swapped.
+   */
+  async getxSTRKInVault(): Promise<Web3Number> {
+    const xstrkToken = Global.getDefaultTokens().find(
+      (t) => t.symbol === "xSTRK",
+    );
+    if (!xstrkToken) {
+      throw new Error(`${this.getTag()}:: xSTRK token not found`);
+    }
+    return new ERC20(this.config).balanceOf(
+      xstrkToken.address.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      xstrkToken.decimals,
+    );
+  }
+
+  /**
+   * Simulates depositing `depositAmount` USDC on Vesu and returns the
+   * incremental STRK that would be borrowed.  Needed to size the AVNU swap
+   * call that is batched together with the Vesu call in the same transaction.
+   */
+  async computeVesuDepositBorrowAmount(
+    depositAmount: Web3Number,
+  ): Promise<Web3Number> {
+    return this.getAdapterById<VesuModifyPositionAdapter>(
+      "vesu_usdc_strk",
+    ).getExpectedDepositDebtDelta(depositAmount);
+  }
+
+  async computeVesuWithdrawDebtDelta(
+    withdrawAmount: Web3Number,
+  ): Promise<Web3Number> {
+    return this.getAdapterById<VesuModifyPositionAdapter>(
+      "vesu_usdc_strk",
+    ).getExpectedWithdrawDebtDelta(withdrawAmount);
+  }
+
+  async getPendingHyperAssets(): Promise<Web3Number> {
+    const xstrkToken = Global.getDefaultTokens().find(
+      (t) => t.symbol === "xSTRK",
+    )!;
+    // TODO: hardcoding for now ( since this is temp method we will use due_assets_from_owner later on )
+    const hyperXstrkRedeemNFT = ContractAddr.from(
+      "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095"
+    );
+    return this.getAdapterById<SvkTrovesAdapter>(
+      "hyper_xstrk",
+    ).getPendingAssetsFromOwnerNFTMethod(
+      hyperXstrkRedeemNFT,
+      this.metadata.additionalInfo.vaultAllocator,
+      xstrkToken.decimals,
+    );
+  }
+
+  // TODO: rn we are just making these functions in the strategy itself but
+  // later on we will move them to the SVKStrategy for generalization
+
+  async getUserTVL(
+    user: ContractAddr,
+    blockIdentifier: BlockIdentifier = "latest",
+  ) {
+    const shares: any = await this.contract.call("balanceOf", [user.address], {
+      blockIdentifier,
+    });
+    const assets: any = await this.contract.call(
+      "convert_to_assets",
+      [uint256.bnToUint256(shares)],
+      { blockIdentifier },
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals,
+    );
+
+    const blockNumber =
+      typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint"
+        ? Number(blockIdentifier)
+        : undefined;
+
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+      blockNumber,
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue,
+    };
+  }
+
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals,
+    );
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue,
+    };
+  }
+
+  async getAUM(): Promise<{
+    net: SingleTokenInfo;
+    prevAum: Web3Number;
+    splits: PositionInfo[];
+  }> {
+    const underlying = this.asset(); // USDC
+    const usdcPrice = await this.pricer.getPrice(underlying.symbol);
+
+    const allPositions: PositionInfo[] = [];
+    for (const adapter of this.metadata.additionalInfo.adapters) {
+      const positions = await adapter.adapter.getPositions();
+      allPositions.push(...positions);
+    }
+
+    let netAUM = new Web3Number(0, underlying.decimals);
+    for (const position of allPositions) {
+      if (position.tokenInfo.address.eq(underlying.address)) {
+        netAUM = netAUM.plus(position.amount);
+      } else {
+        const valueInUSDC = position.usdValue;
+        netAUM = netAUM.plus(valueInUSDC);
+      }
+    }
+
+    const unusedBalance = await this.getUnusedBalance();
+    logger.verbose(
+      `${this.getTag()} unused balance: ${unusedBalance.amount.toNumber()}`,
+    );
+
+    // Since this is only in USDC -> we are taking directly the amount ( ow can use the usdValue as well )
+    netAUM = netAUM.plus(unusedBalance.amount);
+
+    const prevAum = await this.getPrevAUM();
+    logger.verbose(`${this.getTag()} AUM: ${netAUM}`);
+
+    const realAUM: PositionInfo = {
+      tokenInfo: underlying,
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * usdcPrice.price,
+      apy: { apy: 0, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.NONE,
+    };
+
+    // TODO: we can completely remove it since this strategy doesnt include rewards
+    // but for now keeping it for the structure -> eitherways its 0
+    const estimatedAUMDelta: PositionInfo = {
+      tokenInfo: underlying,
+      amount: Web3Number.fromWei("0", underlying.decimals),
+      usdValue: 0,
+      apy: { apy: 0, type: APYType.BASE },
+      remarks: AUMTypes.DEFISPRING,
+      protocol: Protocols.NONE,
+    };
+
+    return {
+      net: {
+        tokenInfo: underlying,
+        amount: netAUM,
+        usdValue: netAUM.toNumber() * usdcPrice.price,
+      },
+      prevAum,
+      splits: [realAUM, estimatedAUMDelta],
+    };
+  }
+
+  // TODO: can refactor later but seems redundant since not being used ANYWHERE
+  // Most of the fund management done through adapters only
+
+  async getFundManagementCall(params: {
+    isDeposit: boolean;
+    leg1DepositAmount: Web3Number;
+  }) {
+    logger.verbose(
+      `${this.getTag()}::getFundManagementCall params: ${JSON.stringify(params)}`,
+    );
+    const allAdapters = this.metadata.additionalInfo.adapters.map(
+      (a) => a.adapter,
+    );
+
+    if (!params.isDeposit) {
+      const unusedBalance = await this.getUnusedBalance();
+      logger.verbose(
+        `${this.getTag()}::getFundManagementCall unusedBalance: ${unusedBalance.amount}, required: ${params.leg1DepositAmount}`,
+      );
+      if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
+        return null;
+      }
+
+      const adapters = await AdapterOptimizer.getAdapterToUse(
+        allAdapters,
+        false,
+        params.leg1DepositAmount,
+      );
+      if (adapters.length > 0) {
+        const proofsInfo = adapters.map((adapter) =>
+          adapter.getProofs(false, this.getMerkleTree()),
+        );
+        const calls: Call[] = [];
+        for (const info of proofsInfo) {
+          const manageCalls = await info.callConstructor({
+            amount: params.leg1DepositAmount,
+          });
+          const call = this.getManageCall(
+            this.getProofGroupsForManageCalls(manageCalls),
+            manageCalls,
+          );
+          calls.push(call);
+        }
+        return calls;
+      }
+
+      throw new Error(
+        `${this.getTag()}::getFundManagementCall: no adapters for withdraw: ${unusedBalance.amount}`,
+      );
+    }
+
+    const adapters = await AdapterOptimizer.getAdapterToUse(
+      allAdapters,
+      true,
+      params.leg1DepositAmount,
+    );
+    if (adapters.length > 0) {
+      const proofsInfo = adapters.map((adapter) =>
+        adapter.getProofs(true, this.getMerkleTree()),
+      );
+      const calls: Call[] = [];
+      for (const info of proofsInfo) {
+        const manageCalls = await info.callConstructor({
+          amount: params.leg1DepositAmount,
+        });
+        const call = this.getManageCall(
+          this.getProofGroupsForManageCalls(manageCalls),
+          manageCalls,
+        );
+        calls.push(call);
+      }
+      return calls;
+    }
+
+    throw new Error(
+      `${this.getTag()}::getFundManagementCall: no adapters for deposit: ${params.leg1DepositAmount}`,
+    );
+  }
+}
+
+function getUSDCBoostedSettings(vaultSettings: USDCBoostedStrategySettings) {
+  vaultSettings.leafAdapters = [];
+
+  const xSTRKToken = Global.getDefaultTokens().find(
+    (t) => t.symbol === "xSTRK",
+  )!;
+
+  // TODO: we are hardcoding for now since one strategy but we can change later on if req.
+  const USDCToken = Global.getDefaultTokens().find((t) => t.symbol === "USDC")!;
+  const STRKToken = Global.getDefaultTokens().find((t) => t.symbol === "STRK")!;
+
+  const baseAdapterConfig: BaseAdapterConfig = {
+    baseToken: USDCToken,
+    supportedPositions: [{ asset: USDCToken, isDebt: false }],
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
+    vaultAllocator: vaultSettings.vaultAllocator,
+    vaultAddress: vaultSettings.vaultAddress,
+  };
+
+  // ── 1. VesuModifyPositionAdapter (USDC collateral / STRK debt) ──
+
+  const vesuModifyPositionAdapter = new VesuModifyPositionAdapter({
+    poolId: vaultSettings.vesuPoolId,
+    collateral: vaultSettings.collateralToken,
+    debt: vaultSettings.debtToken,
+    targetLtv: vaultSettings.targetLTV,
+    maxLtv: vaultSettings.maxLTV,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: USDCToken, isDebt: false },
+      { asset: STRKToken, isDebt: true },
+    ],
+  });
+
+  // ── 2. AvnuAdapter (STRK ↔ xSTRK swaps) ──
+  const avnuAdapter = new AvnuAdapter({
+    baseUrl: AVNU_QUOTE_URL,
+    avnuContract: AVNU_EXCHANGE,
+    slippage: 0.01,
+    minimumExtendedPriceDifferenceForSwapOpen: 0,
+    maximumExtendedPriceDifferenceForSwapClosing: 0,
+    ...baseAdapterConfig,
+    baseToken: STRKToken,
+    supportedPositions: [
+      { asset: STRKToken, isDebt: false },
+      { asset: xSTRKToken, isDebt: false },
+    ],
+  });
+
+  // ── 3. SvkTrovesAdapter (deposit xSTRK into / withdraw from Hyper-xSTRK) ──
+  const svkTrovesAdapter = new SvkTrovesAdapter({
+    ...baseAdapterConfig,
+    baseToken: xSTRKToken,
+    supportedPositions: [{ asset: xSTRKToken, isDebt: false }],
+    strategyVault: vaultSettings.hyperxSTRKVaultAddress,
+    trovesStrategyId: "hyper_xstrk",
+  });
+
+  // Used to track the funds in toAddress ( Vault )
+  // ── 4. TokenTransferAdapter  ──
+  const usdcTransferAdapter = new TokenTransferAdapter({
+    ...baseAdapterConfig,
+    fromAddress: vaultSettings.vaultAllocator,
+    toAddress: vaultSettings.vaultAddress,
+  });
+
+  // ── 5. CommonAdapter (approve + bring liquidity) ──
+  const commonAdapter = new CommonAdapter({
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    manager: vaultSettings.manager,
+    asset: USDCToken.address,
+  });
+
+  // ── Register adapters for position tracking ──
+  vaultSettings.adapters.push(
+    // TODO: generalize the ids
+    { id: "vesu_usdc_strk", adapter: vesuModifyPositionAdapter },
+    // Used to track swapped funds in vaultAllocator
+    { id: "avnu_strk_xstrk", adapter: avnuAdapter },
+    { id: "hyper_xstrk", adapter: svkTrovesAdapter },
+    { id: "usdc_transfer", adapter: usdcTransferAdapter },
+  );
+
+  // ── Register leaf adapters for merkle tree ──
+  // Vesu modify position
+  vaultSettings.leafAdapters.push(() =>
+    vesuModifyPositionAdapter.getDepositLeaf(),
+  );
+  vaultSettings.leafAdapters.push(() =>
+    vesuModifyPositionAdapter.getWithdrawLeaf(),
+  );
+
+  // Avnu swaps (STRK ↔ xSTRK)
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+
+  // Hyper-xSTRK deposit / withdraw
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getWithdrawLeaf());
+
+  // Bring liquidity back to vault
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        USDCToken.address,
+        vaultSettings.vaultAddress,
+        UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY,
+      )
+      .bind(commonAdapter),
+  );
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
+      .bind(commonAdapter),
+  );
+
+  return vaultSettings;
+}
+
+const usdcBoostedSettings: USDCBoostedStrategySettings = {
+  vaultAddress: ContractAddr.from(
+    "0xcdb0e3b2e076a2cdc4ee958b726b47c066239ef91c5ac80c94cf814147b84",
+  ),
+  manager: ContractAddr.from(
+    "0x72eea9bac9fa8cfffda637d3b990851446860c6fd8987d6cb50e659b01ee50f",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x6d3101cff7f821412a99ebe23bb31a1950f93276285102eb4313e3601f5f927",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x47dcc6889ca8db4e9eea8f55421e10f8ce7e356ccb45260a1c49a76f733c309",
+  ),
+  // TODO: not applicable in our case -> remove later ( make it optional if needed)
+  aumOracle: ContractAddr.from("0x0"),
+  leafAdapters: [],
+  adapters: [],
+  // Calc using the maxLTV / targetLTV (0.5)
+  targetHealthFactor: 1.32,
+  // Calc using the maxLTV / maxAcceptableLTV (0.55)
+  minHealthFactor: 1.2,
+  vesuPoolId: VesuPools.Prime,
+  collateralToken: Global.getDefaultTokens().find((t) => t.symbol === "USDC")!,
+  debtToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
+  maxLTV: 0.66,
+  targetLTV: 0.5,
+  hyperxSTRKVaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960",
+  ),
+};
+
+function getStrategySettings(
+  settings: USDCBoostedStrategySettings,
+): IStrategyMetadata<USDCBoostedStrategySettings> {
+  // TODO: we are hardcoding for now since one strategy but we can change later on
+  const USDCToken = Global.getDefaultTokens().find((t) => t.symbol === "USDC")!;
+  const STRKToken = Global.getDefaultTokens().find((t) => t.symbol === "STRK")!;
+
+  return {
+    id: "usdc_boosted",
+    name: "USDC Boosted",
+    description:
+      "Deposits USDC as collateral on Vesu, borrows STRK, swaps to xSTRK, and deposits into Hyper-xSTRK for boosted yield",
+    address: settings.vaultAddress,
+    launchBlock: 8742931,
+    type: "ERC4626" as const,
+    vaultType: {
+      // TODO: can change as per need
+      type: VaultType.META_VAULT,
+      description:
+        "Deposits USDC as collateral on Vesu, borrows STRK, swaps to xSTRK, and deposits into Hyper-xSTRK for boosted yield",
+    },
+    depositTokens: [USDCToken],
+    additionalInfo: getUSDCBoostedSettings(settings),
+    // TODO: config lateron
+    risk: {
+      riskFactor: [],
+      netRisk: 0,
+      notARisks: [],
+    },
+    protocols: [Protocols.VESU, Protocols.TROVES],
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png",
+    },
+    settings: {
+      maxTVL: Web3Number.fromWei(0, USDCToken.decimals),
+      isPaused: false,
+      isAudited: false,
+      isInstantWithdrawal: false,
+      hideHarvestInfo: true,
+      quoteToken: USDCToken,
+      alerts: [
+        {
+          tab: "withdraw" as const,
+          text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 1-2 hours. You can monitor the status in transactions tab.",
+          type: "info" as const,
+        },
+      ],
+    },
+    contractDetails: getContractDetails(settings),
+    // TODO: config later
+    faqs: [],
+    investmentSteps: [
+      "Deposit USDC into the vault",
+      "USDC is supplied as collateral on Vesu, STRK is borrowed",
+      "Borrowed STRK is swapped to xSTRK via Avnu",
+      "xSTRK is deposited into the Hyper-xSTRK vault for additional yield",
+      "On withdrawal, the pipeline reverses to return USDC",
+    ],
+    // TODO: config later
+    tags: [StrategyTag.META_VAULT],
+    security: {
+      auditStatus: AuditStatus.AUDITED,
+      sourceCode: {
+        type: SourceCodeType.CLOSED_SOURCE,
+        contractLink: "https://github.com/trovesfi/troves-contracts",
+      },
+      accessControl: {
+        type: AccessControlType.STANDARD_ACCOUNT,
+        addresses: [ContractAddr.from("0x0")],
+        timeLock: "2 Days",
+      },
+    },
+    redemptionInfo: {
+      instantWithdrawalVault: InstantWithdrawalVault.NO,
+      redemptionsInfo: [
+        {
+          title: "Typical Duration",
+          description: "1-2 hours",
+        },
+      ],
+      alerts: [
+        {
+          type: "info",
+          text: "Redemption times are estimates and may vary based on network conditions and liquidity requirements.",
+          tab: "withdraw",
+        },
+      ],
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null,
+  };
+}
+
+export const USDCBoostedStrategies: IStrategyMetadata<USDCBoostedStrategySettings>[] =
+  [getStrategySettings(usdcBoostedSettings)];

package/src/strategies/vesu-extended-strategy/services/executionService.ts

@@ -1162,6 +1162,7 @@ export class ExecutionService {
       );
       const netExecutionPrice = this._getNetExecutionPrice(isIncrease);
 
+      // todo doubt. I dont think its a good idea to extended short below ideal price, nor above in long case. 
       let executionPrice: number;
 
       if (hasVesuSwapRoute) {