@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.41

package/src/strategies/token-boosted-xstrk-carry-strategy.tsx

@@ -0,0 +1,1262 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Global } from "@/global";
+import {
+  AccessControlType,
+  AuditStatus,
+  FAQ,
+  getMainnetConfig,
+  getNoRiskTags,
+  IConfig,
+  InstantWithdrawalVault,
+  IStrategyMetadata,
+  Protocols,
+  RiskFactor,
+  RiskType,
+  SourceCodeType,
+  StrategyLiveStatus,
+  StrategyTag,
+  TokenInfo,
+  VaultPosition,
+  VaultType,
+} from "@/interfaces";
+import {
+  CounterpartyRiskLevel,
+  DepegRiskLevel,
+  LiquidationRiskLevel,
+  LowLiquidityRiskLevel,
+  MarketRiskLevel,
+  OracleRiskLevel,
+  SmartContractRiskLevel,
+  TechnicalRiskLevel,
+} from "@/interfaces/risks";
+import { ERC20, PricerFromApi, TokenMarketData } from "@/modules";
+import { PricerBase } from "@/modules/pricerBase";
+import { logger, assert } from "@/utils";
+import { BlockIdentifier, Call, uint256, num } from "starknet";
+import {
+  SingleTokenInfo,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
+import { SVKStrategy } from "./svk-strategy";
+import {
+  APYType,
+  AvnuAdapter,
+  BaseAdapterConfig,
+  CommonAdapter,
+  PositionInfo,
+  TokenTransferAdapter,
+  VesuModifyPositionAdapter,
+} from "./universal-adapters";
+import { AdapterOptimizer } from "./universal-adapters/adapter-optimizer";
+import {
+  AVNU_EXCHANGE,
+  AVNU_QUOTE_URL,
+} from "./universal-adapters/adapter-utils";
+import { SvkTrovesAdapter } from "./universal-adapters/svk-troves-adapter";
+import { VesuPools, VesuAdapter } from "./universal-adapters/vesu-adapter";
+import {
+  AUMTypes,
+  getContractDetails,
+  UNIVERSAL_MANAGE_IDS,
+  UniversalStrategySettings,
+} from "./universal-strategy";
+
+export interface BoostedxSTRKCarryStrategySettings extends UniversalStrategySettings {
+  depositToken: TokenInfo; // USDC, WBTC, etc. - the collateral token
+  debtToken: TokenInfo; // STRK, etc. - the debt token
+  lstHyperToken: TokenInfo; // xSTRK, etc. - the LST token deposited into hyper vault
+  vesuPoolId: ContractAddr;
+  maxLTV: number; // e.g. 0.66
+  targetLTV: number;
+  hyperLstVaultAddress: ContractAddr; // Address of the hyper vault for LST
+  hyperLstRedeemNFT: ContractAddr; // NFT contract for pending hyper redeems
+  trovesStrategyId: string; // e.g. "hyper_xstrk" - used for APY fetching
+  // TODO: will refac later on to a better approach where we dont need flags
+  hasBtcFiRewards: boolean; // Whether this strategy has BTC.Fi rewards (affects reporting flow)
+  // Adapter IDs computed from token symbols
+  adapterIds?: {
+    vesu: string;
+    avnu: string;
+    hyper: string;
+    transfer: string;
+  };
+}
+
+export class BoostedxSTRKCarryStrategy<
+  S extends BoostedxSTRKCarryStrategySettings,
+> 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 `${BoostedxSTRKCarryStrategy.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;
+  }
+
+  private async getTruePriceForToken(token: TokenInfo): Promise<number> {
+    return new TokenMarketData(this.pricer, this.config).getTruePrice(token);
+  }
+
+  async getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number) {
+    const lst = this.metadata.additionalInfo.lstHyperToken;
+    const lstTruePrice = await this.getTruePriceForToken(lst);
+    const minOutputAmount = amountInUnderlying
+      .dividedBy(lstTruePrice)
+      .multipliedBy(0.99979); // 0.21 % avnu fees
+    return new Web3Number(minOutputAmount.toString(), lst.decimals);
+  }
+
+  async getMinOutputAmountLSTSell(amountInLST: Web3Number) {
+    const lst = this.metadata.additionalInfo.lstHyperToken;
+    const lstTruePrice = await this.getTruePriceForToken(lst);
+    return amountInLST.multipliedBy(lstTruePrice).multipliedBy(0.995);
+  }
+
+  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>(
+        this.metadata.additionalInfo.adapterIds!.vesu,
+      ),
+      params.isDeposit,
+      params.leg1DepositAmount,
+      params.debtAmount ? { debtAmount: params.debtAmount } : undefined,
+    );
+  }
+
+  async getVesuPositions(): Promise<VaultPosition[]> {
+    const positions = await this.getAdapterById<VesuModifyPositionAdapter>(
+      this.metadata.additionalInfo.adapterIds!.vesu,
+    ).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>(
+      this.metadata.additionalInfo.adapterIds!.vesu,
+    );
+    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>(
+        this.metadata.additionalInfo.adapterIds!.hyper,
+      ),
+      params.isDeposit,
+      params.amount,
+    );
+  }
+
+  async getAvnuSwapCall(params: {
+    isDeposit: boolean;
+    amount: Web3Number;
+    minAmount?: Web3Number;
+  }): Promise<Call> {
+    logger.verbose(
+      `${this.getTag()}::getAvnuSwapCall isDeposit=${params.isDeposit}, amount=${params.amount}, minAmount=${params.minAmount?.toNumber()}`,
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById<AvnuAdapter>(
+        this.metadata.additionalInfo.adapterIds!.avnu,
+      ),
+      params.isDeposit,
+      params.amount,
+      params.minAmount ? { minAmount: params.minAmount } : undefined,
+    );
+  }
+
+  /**
+   * Returns the deposit token balance sitting idle inside the vault contract itself.
+   * This balance can offset the required liquidity during withdrawal processing.
+   */
+  async getUnusedBalanceVault(): Promise<Web3Number> {
+    const depositToken = this.metadata.additionalInfo.depositToken;
+    return new ERC20(this.config).balanceOf(
+      depositToken.address,
+      this.metadata.additionalInfo.vaultAddress,
+      depositToken.decimals,
+    );
+  }
+
+  /**
+   * Returns the current borrow token balance sitting unused in the vault allocator.
+   * This covers borrow token 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 LST 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 LST lands here and is ready to be swapped.
+   */
+  async getLstInVaultAllocator(): Promise<Web3Number> {
+    const lstToken = this.metadata.additionalInfo.lstHyperToken;
+    return new ERC20(this.config).balanceOf(
+      lstToken.address.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      lstToken.decimals,
+    );
+  }
+
+  /**
+   * Simulates depositing `depositAmount` on Vesu and returns the
+   * incremental borrow token 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>(
+      this.metadata.additionalInfo.adapterIds!.vesu,
+    ).getExpectedDepositDebtDelta(depositAmount);
+  }
+
+  async computeVesuWithdrawDebtDelta(
+    withdrawAmount: Web3Number,
+  ): Promise<Web3Number> {
+    return this.getAdapterById<VesuModifyPositionAdapter>(
+      this.metadata.additionalInfo.adapterIds!.vesu,
+    ).getExpectedWithdrawDebtDelta(withdrawAmount);
+  }
+
+  async getPendingHyperAssets(): Promise<Web3Number> {
+    const lstToken = this.metadata.additionalInfo.lstHyperToken;
+    const hyperLstRedeemNFT = this.metadata.additionalInfo.hyperLstRedeemNFT;
+    return this.getAdapterById<SvkTrovesAdapter>(
+      this.metadata.additionalInfo.adapterIds!.hyper,
+    ).getPendingAssetsFromOwnerNFTMethod(
+      hyperLstRedeemNFT,
+      this.metadata.additionalInfo.vaultAllocator,
+      lstToken.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 getUserPositionCards(
+    input: UserPositionCardsInput,
+  ): Promise<UserPositionCard[]> {
+    const cards = await super.getUserPositionCards(input);
+    const realizedApyRaw = await this.getUserRealizedAPY().catch((error) => {
+      logger.warn(
+        `${this.getTag()}::getUserPositionCards realized APY fallback`,
+        error,
+      );
+      return null;
+    });
+
+    const realizedApy =
+      typeof realizedApyRaw === "number"
+        ? this.formatPercentForCard(realizedApyRaw)
+        : "N/A";
+
+    cards.push({
+      title: "Realized APY",
+      tooltip:
+        this.metadata.realizedApyMethodology ||
+        "Realized APY is based on past 14 days performance",
+      value: realizedApy,
+    });
+
+    return cards;
+  }
+
+  async getAUM(): Promise<{
+    net: SingleTokenInfo;
+    prevAum: Web3Number;
+    splits: PositionInfo[];
+  }> {
+    const underlying = this.asset(); // Deposit token (USDC, WBTC, etc.)
+    const depositTokenPrice = await this.pricer.getPrice(underlying.symbol);
+
+    const allPositions = await this.getVaultPositions();
+
+    let netAUM = new Web3Number(0, underlying.decimals);
+    for (const position of allPositions) {
+      if (position.token.address.eq(underlying.address)) {
+        // Same token as underlying - add amount directly
+        netAUM = netAUM.plus(position.amount);
+      } else {
+        // Different token - convert USD value to underlying token amount
+        const amountInUnderlying = new Web3Number(
+          position.usdValue.toString(),
+          underlying.decimals,
+        ).dividedBy(depositTokenPrice.price);
+        netAUM = netAUM.plus(amountInUnderlying);
+      }
+    }
+
+    const prevAum = await this.getPrevAUM();
+    logger.verbose(`${this.getTag()} Actual AUM: ${netAUM}`);
+
+    // Calculate BTCFI rewards contribution
+    const rewardAssets = await this.getRewardsAUM(prevAum);
+    logger.verbose(`${this.getTag()} Rewards AUM: ${rewardAssets}`);
+
+    // Sum up total AUM
+    const totalAUM = netAUM.plus(rewardAssets);
+    logger.verbose(`${this.getTag()} Total AUM: ${totalAUM}`);
+
+    const realAUM: PositionInfo = {
+      tokenInfo: underlying,
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * depositTokenPrice.price,
+      apy: { apy: 0, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.NONE,
+    };
+
+    const estimatedAUMDelta: PositionInfo = {
+      tokenInfo: underlying,
+      amount: rewardAssets,
+      usdValue: rewardAssets.toNumber() * depositTokenPrice.price,
+      apy: { apy: 0, type: APYType.BASE },
+      remarks: AUMTypes.BTCFI,
+      protocol: Protocols.NONE,
+    };
+
+    return {
+      net: {
+        tokenInfo: underlying,
+        amount: totalAUM,
+        usdValue: totalAUM.toNumber() * depositTokenPrice.price,
+      },
+      prevAum,
+      splits: [realAUM, estimatedAUMDelta],
+    };
+  }
+
+  /**
+   * Get Vesu APYs for collateral and debt positions
+   */
+  async getVesuAPYs(): Promise<{
+    baseAPYs: number[];
+    rewardAPYs: number[];
+    positions: VaultPosition[];
+  }> {
+    const vesuAdapter = this.getAdapterById<VesuModifyPositionAdapter>(
+      this.metadata.additionalInfo.adapterIds!.vesu,
+    );
+
+    // Get Vesu pool data
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const pool = allVesuPools.pools.find((p: any) =>
+      vesuAdapter.config.poolId.eqString(num.getHexString(p.id)),
+    );
+
+    if (!pool) {
+      throw new Error(
+        `${this.getTag()}::getVesuAPYs: Pool not found for ${vesuAdapter.config.poolId.address}`,
+      );
+    }
+
+    // logger.verbose(
+    //   `${this.getTag()}::getVesuAPYs: vesu-pool: ${JSON.stringify(pool)}`,
+    // );
+
+    // Get positions
+    const positions = await this.getVesuPositions();
+    logger.verbose(
+      `${this.getTag()}::getVesuAPYs: positions: ${JSON.stringify(positions)}`,
+    );
+
+    const baseAPYs: number[] = [];
+    const rewardAPYs: number[] = [];
+
+    // Find collateral and debt asset stats
+    const collateralAsset = pool.assets.find(
+      (a: any) =>
+        a.symbol.toLowerCase() ===
+        vesuAdapter.config.collateral.symbol.toLowerCase(),
+    )?.stats!;
+    const debtAsset = pool.assets.find(
+      (a: any) =>
+        a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase(),
+    )?.stats!;
+
+    if (!collateralAsset || !debtAsset) {
+      throw new Error(
+        `${this.getTag()}::getVesuAPYs: Collateral or debt asset stats not found`,
+      );
+    }
+
+    const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+    const borrowApr = Number(debtAsset.borrowApr.value) / 1e18;
+    const collateralRewardsApr = this.metadata.additionalInfo.hasBtcFiRewards
+      ? Number(collateralAsset.btcFiSupplyApr?.value || "0") / 1e18
+      : 0;
+
+    logger.verbose(
+      `${this.getTag()}::getVesuAPYs: collateralRewardsApr: ${collateralRewardsApr}`,
+    );
+    logger.verbose(
+      `${this.getTag()}::getVesuAPYs: collateralAsset: ${JSON.stringify(collateralAsset)}`,
+    );
+    logger.verbose(
+      `${this.getTag()}::getVesuAPYs: supplyApy=${supplyApy}, borrowApr=${borrowApr}, collateralRewards=${collateralRewardsApr}`,
+    );
+
+    // Collateral: supply APY, Debt: borrow APR (cost)
+    baseAPYs.push(supplyApy, borrowApr);
+    rewardAPYs.push(collateralRewardsApr, 0);
+
+    logger.verbose(
+      `${this.getTag()}::getVesuAPYs: baseAPYs: ${JSON.stringify(baseAPYs)}, rewardAPYs: ${JSON.stringify(rewardAPYs)}`,
+    );
+
+    assert(
+      baseAPYs.length === positions.length,
+      "APYs and positions length mismatch",
+    );
+
+    return { baseAPYs, rewardAPYs, positions };
+  }
+
+  /**
+   * Get APY from the Hyper LST vault position
+   */
+  async getHyperVaultAPY(): Promise<{ apy: number; weight: number }> {
+    try {
+      const hyperAdapter = this.getAdapterById<SvkTrovesAdapter>(
+        this.metadata.additionalInfo.adapterIds!.hyper,
+      );
+      const positions = await hyperAdapter.getPositions();
+
+      if (positions.length === 0 || positions[0].amount.isZero()) {
+        return { apy: 0, weight: 0 };
+      }
+
+      const position = positions[0];
+      const apy = position.apy.apy;
+      const weight = position.usdValue;
+
+      logger.verbose(
+        `${this.getTag()}::getHyperVaultAPY: apy=${apy}, weight=${weight}`,
+      );
+
+      return { apy, weight };
+    } catch (error) {
+      logger.warn(
+        `${this.getTag()}::getHyperVaultAPY: Error getting Hyper vault APY: ${error}`,
+      );
+      return { apy: 0, weight: 0 };
+    }
+  }
+
+  /**
+   * Get APY for unused balance (idle funds in vault allocator)
+   */
+  protected async getUnusedBalanceAPY() {
+    return {
+      apy: 0,
+      weight: 0,
+    };
+  }
+
+  /**
+   * Compute weighted APY from individual APYs, weights, and total AUM
+   */
+  private computeAPY(
+    apys: number[],
+    weights: number[],
+    totalWeight: number,
+  ): number {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    logger.verbose(
+      `${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, totalWeight: ${totalWeight}`,
+    );
+    return weightedSum / totalWeight;
+  }
+
+  /**
+   * Calculate net APY from base and reward APYs
+   */
+  protected async returnNetAPY(
+    baseAPYs: number[],
+    rewardAPYs: number[],
+    weights: number[],
+    totalWeightUSD: number,
+  ) {
+    // If no positions, return 0
+    if (weights.every((p) => p == 0)) {
+      return {
+        net: 0,
+        splits: [
+          {
+            apy: 0,
+            id: "base",
+          },
+          {
+            apy: 0,
+            id: "btcfi",
+          },
+        ],
+      };
+    }
+
+    const baseAPY = this.computeAPY(baseAPYs, weights, totalWeightUSD);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights, totalWeightUSD);
+    const netAPY = baseAPY + rewardAPY;
+    logger.verbose(
+      `${this.getTag()}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`,
+    );
+    return {
+      net: netAPY,
+      splits: [
+        {
+          apy: baseAPY,
+          id: "base",
+        },
+        {
+          apy: rewardAPY,
+          id: "btcfi",
+        },
+      ],
+    };
+  }
+
+  /**
+   * Calculate net APY across all positions (Vesu, Hyper vault, unused balance)
+   * weighted by USD value
+   */
+  // TODO: will be reviewing this later on, we only need BTCFI APY for now for AUM
+  async netAPY(): Promise<{
+    net: number;
+    splits: { apy: number; id: string }[];
+  }> {
+    try {
+      // Get Vesu APYs and positions
+      const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+
+      // Get Hyper vault APY
+      const hyperAPY = await this.getHyperVaultAPY();
+      baseAPYs.push(hyperAPY.apy);
+      rewardAPYs.push(0); // Hyper vault rewards already included in its APY
+
+      // Get unused balance APY
+      const unusedBalanceAPY = await this.getUnusedBalanceAPY();
+      baseAPYs.push(unusedBalanceAPY.apy);
+      rewardAPYs.push(0);
+
+      // Compute weights - debt usdValue is already negative from adapter
+      const weights = positions.map((p) => p.usdValue);
+      weights.push(hyperAPY.weight);
+      weights.push(unusedBalanceAPY.weight);
+
+      logger.verbose(
+        `${this.getTag()}::netAPY: weights: ${JSON.stringify(weights)}`,
+      );
+
+      // Calculate total weight (current total AUM in USD)
+      const totalWeightUSD = weights.reduce((sum, weight) => sum + weight, 0);
+
+      logger.verbose(
+        `${this.getTag()}::netAPY: totalWeightUSD: ${totalWeightUSD}`,
+      );
+
+      return this.returnNetAPY(baseAPYs, rewardAPYs, weights, totalWeightUSD);
+    } catch (error: any) {
+      logger.error(
+        `${this.getTag()}::netAPY: Error calculating net APY: ${error?.message || error}`,
+      );
+      return {
+        net: 0,
+        splits: [
+          {
+            apy: 0,
+            id: "base",
+          },
+          {
+            apy: 0,
+            id: "btcfi",
+          },
+        ],
+      };
+    }
+  }
+
+  /**
+   * Calculate future rewards (e.g. BTCFI rewards) contribution to AUM
+   * Similar to universal-strategy.tsx approach
+   */
+  protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
+    if (!this.metadata.additionalInfo.hasBtcFiRewards) {
+      return Web3Number.fromWei("0", this.asset().decimals);
+    }
+
+    try {
+      const lastReportTime = await this.contract.call(
+        "last_report_timestamp",
+        [],
+      );
+
+      // Calculate estimated growth from rewards
+      const netAPY = await this.netAPY();
+      // Account only 80% of value for conservative estimate
+      const btcfiAPY =
+        (netAPY.splits.find((s) => s.id === "btcfi")?.apy || 0) * 0.8;
+
+      if (!btcfiAPY) {
+        logger.verbose(
+          `${this.getTag()} No BTCFI APY found, returning 0 rewards`,
+        );
+        return Web3Number.fromWei("0", this.asset().decimals);
+      }
+
+      // Compute rewards contribution to AUM
+      const timeDiff = Math.round(Date.now() / 1000) - Number(lastReportTime);
+      const growthRate = (timeDiff * btcfiAPY) / (365 * 24 * 60 * 60);
+      const rewardAssets = prevAum.multipliedBy(growthRate);
+
+      logger.verbose(
+        `${this.getTag()} BtcFi AUM time difference: ${timeDiff}s`,
+      );
+      logger.verbose(`${this.getTag()} Previous AUM: ${prevAum.toString()}`);
+      logger.verbose(`${this.getTag()} BtcFi APY: ${btcfiAPY}`);
+      logger.verbose(`${this.getTag()} Growth rate: ${growthRate}`);
+      logger.verbose(
+        `${this.getTag()} Rewards AUM: ${rewardAssets.toString()}`,
+      );
+
+      return rewardAssets;
+    } catch (error: any) {
+      logger.warn(
+        `${this.getTag()} Error calculating rewards AUM: ${error?.message || error}`,
+      );
+      return Web3Number.fromWei("0", this.asset().decimals);
+    }
+  }
+
+  // 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 getBoostedxSTRKCarrySettings(
+  vaultSettings: BoostedxSTRKCarryStrategySettings,
+) {
+  vaultSettings.leafAdapters = [];
+
+  // Use metadata-driven token configuration
+  const depositToken = vaultSettings.depositToken;
+  const debtToken = vaultSettings.debtToken;
+  const lstToken = vaultSettings.lstHyperToken;
+
+  // Build dynamic adapter IDs based on token symbols
+  const adapterIds = {
+    vesu: `vesu_${depositToken.symbol.toLowerCase()}_${debtToken.symbol.toLowerCase()}`,
+    avnu: `avnu_${debtToken.symbol.toLowerCase()}_${lstToken.symbol.toLowerCase()}`,
+    hyper: `hyper_${lstToken.symbol.toLowerCase()}`,
+    transfer: `${depositToken.symbol.toLowerCase()}_transfer`,
+  };
+  vaultSettings.adapterIds = adapterIds;
+
+  const baseAdapterConfig: BaseAdapterConfig = {
+    baseToken: depositToken,
+    supportedPositions: [{ asset: depositToken, isDebt: false }],
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
+    vaultAllocator: vaultSettings.vaultAllocator,
+    vaultAddress: vaultSettings.vaultAddress,
+  };
+
+  // ── 1. VesuModifyPositionAdapter (deposit token collateral / borrow token debt) ──
+
+  const vesuModifyPositionAdapter = new VesuModifyPositionAdapter({
+    poolId: vaultSettings.vesuPoolId,
+    collateral: depositToken,
+    debt: debtToken,
+    targetLtv: vaultSettings.targetLTV,
+    maxLtv: vaultSettings.maxLTV,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: depositToken, isDebt: false },
+      { asset: debtToken, isDebt: true },
+    ],
+  });
+
+  // ── 2. AvnuAdapter (borrow token ↔ LST swaps) ──
+  const avnuAdapter = new AvnuAdapter({
+    baseUrl: AVNU_QUOTE_URL,
+    avnuContract: AVNU_EXCHANGE,
+    slippage: 0.01,
+    minimumExtendedPriceDifferenceForSwapOpen: 0,
+    maximumExtendedPriceDifferenceForSwapClosing: 0,
+    ...baseAdapterConfig,
+    baseToken: debtToken,
+    supportedPositions: [
+      { asset: debtToken, isDebt: false },
+      { asset: lstToken, isDebt: false },
+    ],
+  });
+
+  // ── 3. SvkTrovesAdapter (deposit LST into / withdraw from Hyper vault) ──
+  const svkTrovesAdapter = new SvkTrovesAdapter({
+    ...baseAdapterConfig,
+    baseToken: lstToken,
+    supportedPositions: [{ asset: lstToken, isDebt: false }],
+    strategyVault: vaultSettings.hyperLstVaultAddress,
+    trovesStrategyId: vaultSettings.trovesStrategyId,
+    redeemRequestNFT: vaultSettings.hyperLstRedeemNFT,
+  });
+
+  // ── 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: depositToken.address,
+  });
+
+  // ── Register adapters for position tracking ──
+  vaultSettings.adapters.push(
+    { id: adapterIds.vesu, adapter: vesuModifyPositionAdapter },
+    // Used to track swapped funds in vaultAllocator
+    { id: adapterIds.avnu, adapter: avnuAdapter },
+    { id: adapterIds.hyper, adapter: svkTrovesAdapter },
+  );
+
+  // ── Register leaf adapters for merkle tree ──
+  // Vesu modify position
+  vaultSettings.leafAdapters.push(() =>
+    vesuModifyPositionAdapter.getDepositLeaf(),
+  );
+  vaultSettings.leafAdapters.push(() =>
+    vesuModifyPositionAdapter.getWithdrawLeaf(),
+  );
+
+  // Avnu swaps (borrow token ↔ LST)
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+
+  // Hyper LST vault deposit / withdraw
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getWithdrawLeaf());
+
+  // Bring liquidity back to vault
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        depositToken.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 boostedxSTRKCarrySettings: BoostedxSTRKCarryStrategySettings = {
+  vaultAddress: ContractAddr.from(
+    "0x02490bd7fa730790e220b40a3cb7bec14ddf030e15c9813610aabbe391f781c4",
+  ),
+  manager: ContractAddr.from(
+    "0x011cd83d2a8c4da86da7b2e2351e9d073568b2fe0fef00dbbdab03ebfc7923b9",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x0671f407da7daeb57a9ecfea17bd61b8fcb987d8d0c43855e5f07c2f08a424be",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x0669d0af171fb4b5d93a2e51f897ae3a2526b0011120fd30e20922de6aa204a1",
+  ),
+  // Not there for USDC but will be there for WBTC
+  aumOracle: ContractAddr.from("0x0"),
+  leafAdapters: [],
+  adapters: [],
+  // Calc using the maxLTV / targetLTV (0.5)
+  targetHealthFactor: 1.36,
+  // Calc using the maxLTV / maxAcceptableLTV (0.55)
+  minHealthFactor: 1.3,
+  vesuPoolId: VesuPools.Prime,
+  // New metadata-driven token configuration
+  depositToken: Global.getDefaultTokens().find((t) => t.symbol === "USDC")!,
+  debtToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
+  lstHyperToken: Global.getDefaultTokens().find((t) => t.symbol === "xSTRK")!,
+  maxLTV: 0.68,
+  targetLTV: 0.5,
+  // BTC.Fi rewards flag - false for USDC (uses old report flow)
+  hasBtcFiRewards: false,
+  // New fields
+  hyperLstVaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960",
+  ),
+  hyperLstRedeemNFT: ContractAddr.from(
+    "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095",
+  ),
+  trovesStrategyId: "hyper_xstrk",
+};
+
+const wbtcBoostedSettings: BoostedxSTRKCarryStrategySettings = {
+  vaultAddress: ContractAddr.from(
+    "0x00a4c7c06313a3e06e408dd19a57e633d26cec5b9c4483223bca5d5b467f4ff6",
+  ),
+  manager: ContractAddr.from(
+    "0x002aef32849cd9c011fe5fa09940d818b5895370d0a5076d9e0b95fee91bbad8",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x006b7896f559084862c7a2e6606a9aecadc1367b61b0264225e5890401031337",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x05502bd98af66c3d1227aa4ac7107eb6867b1686c02a62e2edbda91a686be1e3",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x03bd63a5e03de8af1fc28d80c016511d739303eacec67767d50608b1fee6a7df",
+  ),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.4,
+  minHealthFactor: 1.35,
+  vesuPoolId: VesuPools.Prime,
+  depositToken: Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
+  debtToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
+  lstHyperToken: Global.getDefaultTokens().find((t) => t.symbol === "xSTRK")!,
+  maxLTV: 0.7,
+  targetLTV: 0.5,
+  hasBtcFiRewards: true,
+  hyperLstVaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960",
+  ),
+  hyperLstRedeemNFT: ContractAddr.from(
+    "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095",
+  ),
+  trovesStrategyId: "hyper_xstrk",
+};
+
+// Risk weights drive the displayed net risk score (weighted average of factor levels).
+// Highest weights go to risks that can directly impair principal or block exits; lower weights
+// for mitigated or secondary drivers. Weights sum to 100 for easy reasoning about share of total.
+const boostedCarryRiskFactors: RiskFactor[] = [
+  {
+    type: RiskType.SMART_CONTRACT_RISK,
+    value: SmartContractRiskLevel.WELL_AUDITED,
+    // 20% — core trust assumption; SVK is audited but still multi-contract (vault, manager, adapters).
+    weight: 20,
+    reason:
+      "Built on the Starknet Vault Kit (SVK), with audits under the Sherlock-audited branch.",
+  },
+  {
+    type: RiskType.LIQUIDATION_RISK,
+    value: LiquidationRiskLevel.MODERATE_PROBABILITY,
+    // 20% — tied with smart contract; uncorrelated collateral/debt is the main principal risk here.
+    weight: 20,
+    reason:
+      "Collateral (USDC or WBTC) and STRK debt are not price-correlated. We target ~50% LTV and rebalance above ~55%, with a health-factor buffer, but extreme moves or prolonged monitoring gaps can still trigger liquidation.",
+  },
+  {
+    type: RiskType.LOW_LIQUIDITY_RISK,
+    value: LowLiquidityRiskLevel.MODERATE_CONCERNS,
+    // 15% — below liquidation but above ops risks; every unwind/withdraw depends on xSTRK→STRK depth.
+    weight: 15,
+    reason:
+      "Closing the loop requires selling xSTRK to STRK on DEXes to repay Vesu debt. xSTRK liquidity can be thin at fair prices; larger withdrawals or rebalances may take longer or complete in smaller chunks.",
+  },
+  {
+    type: RiskType.TECHNICAL_RISK,
+    value: TechnicalRiskLevel.SOME_COMPLEXITY,
+    // 13% — monitoring/rebalancing stack matters, but usually recoverable without instant loss.
+    weight: 13,
+    reason:
+      "Yield routes across Vesu, Avnu, and Hyper xSTRK with automated monitoring. Technical failures can delay rebalancing.",
+  },
+  {
+    type: RiskType.DEPEG_RISK,
+    value: DepegRiskLevel.OCCASIONAL_DEPEG,
+    // 12% — affects yield and swap notionals; USDC/WBTC depeg is rarer than xSTRK/STRK drift.
+    weight: 12,
+    reason:
+      "xSTRK yield depends on its exchange rate vs STRK; USDC and WBTC carry standard stablecoin and BTC market risks.",
+  },
+  {
+    type: RiskType.ORACLE_RISK,
+    value: OracleRiskLevel.SINGLE_RELIABLE,
+    // 10% — Vesu HF depends on feeds; Starknet oracles are established but not redundant here.
+    weight: 10,
+    reason: "Vesu collateral and debt valuations rely on Starknet price feeds.",
+  },
+  {
+    type: RiskType.COUNTERPARTY_RISK,
+    value: CounterpartyRiskLevel.REPUTABLE_COUNTERPARTY,
+    // 10% — same tier as oracle; Vesu/Endur/Troves are mature but still protocol counterparty risk.
+    weight: 10,
+    reason:
+      "Exposure to Vesu lending, Endur (xSTRK), and Troves Hyper vault infrastructure.",
+  },
+  {
+    type: RiskType.MARKET_RISK,
+    value: MarketRiskLevel.MODERATE_VOLATILITY,
+    // 5% — largely captured by liquidation + depeg factors; kept small to avoid double-counting vol.
+    weight: 5,
+    reason:
+      "STRK, BTC, and stablecoin volatility can move loan-to-value and swap costs.",
+  },
+];
+
+function getBoostedCarryRisk() {
+  const netRisk =
+    boostedCarryRiskFactors.reduce(
+      (acc, curr) => acc + curr.value * curr.weight,
+      0,
+    ) / boostedCarryRiskFactors.reduce((acc, curr) => acc + curr.weight, 0);
+  return {
+    riskFactor: boostedCarryRiskFactors,
+    netRisk,
+    notARisks: getNoRiskTags(boostedCarryRiskFactors),
+  };
+}
+
+function getBoostedCarryFAQs(
+  depositSymbol: string,
+  debtSymbol: string,
+  lstSymbol: string,
+): FAQ[] {
+  return [
+    {
+      question: `What is ${depositSymbol} Boosted?`,
+      answer: `${depositSymbol} Boosted is a carry-style vault: your ${depositSymbol} is supplied as collateral on Vesu, ${debtSymbol} is borrowed, swapped to ${lstSymbol}, and deposited into Hyper-${lstSymbol} for additional yield on top of the lending loop.`,
+    },
+    {
+      question: "How does this strategy generate yield?",
+      answer: `Yield comes from several layers: ${lstSymbol} staking yield inside Hyper-${lstSymbol}, the spread between borrowing ${debtSymbol} and holding ${lstSymbol}, and efficient routing via Avnu. The vault targets about 50% loan-to-value and rebalances when LTV rises above ~55% so risk and yield stay in balance.`,
+    },
+    {
+      question: "Which protocols are used?",
+      answer: (
+        <span>
+          <strong>Vesu</strong> for collateral and borrowing,{" "}
+          <strong>Avnu</strong> for swaps, <strong>Endur</strong> for{" "}
+          {lstSymbol}, and the Troves <strong>Hyper-{lstSymbol}</strong> vault
+          for the boosted leg.
+        </span>
+      ),
+    },
+    {
+      question: "Is there liquidation risk?",
+      answer: `Yes. Your ${depositSymbol} collateral and ${debtSymbol} debt can move in different directions, which affects your health factor on Vesu. We actively monitor positions and rebalance automatically through our systems to keep loan-to-value near target. However, unexpected technical failures or very sharp market moves can still lead to liquidation. Under normal conditions we aim for a buffer of roughly 30% adverse price movement before liquidation becomes likely — but if monitoring is unavailable for many hours during a trending market, that buffer can be consumed. In extreme scenarios, liquidation remains possible.`,
+    },
+    {
+      question: "What do I receive when I deposit?",
+      answer:
+        "You receive vault tokens representing your share of the vault. They reflect both principal and accrued yield.",
+    },
+    {
+      question: "How long do withdrawals take?",
+      answer:
+        "Withdrawals typically take 1–2 hours. You receive an NFT for your request; funds are sent to the NFT owner once the vault unwinds its positions. The vault must sell xSTRK back to STRK to repay debt — if DEX liquidity is thin or your withdrawal is large, unwinding can take longer or happen in smaller steps to limit slippage.",
+    },
+    {
+      question: "Is this vault non-custodial?",
+      answer:
+        "Yes. The vault runs on-chain. You hold your vault tokens, and positions are transparent via on-chain contracts.",
+    },
+    {
+      question: "Are there any fees?",
+      answer:
+        "Troves charges a 15% performance fee on yield only — not on your deposited principal. The APY shown is already net of this fee. When you withdraw, a 0.1% redemption fee applies. That small fee helps keep the vault efficient for long-term depositors, very short stays create extra swap and rebalancing costs for everyone. If you stay for a reasonable period, your yield will typically far outweigh this one-time charge.",
+    },
+    {
+      question: "Is the vault audited?",
+      answer: (
+        <span>
+          Yes. The strategy is built on the audited Starknet Vault Kit. See the
+          security details beside the strategy name and the{" "}
+          <a
+            href="https://github.com/trovesfi/starknet_vault_kit/tree/sherlock-audited"
+            target="_blank"
+            rel="noopener noreferrer"
+            style={{ textDecoration: "underline" }}
+          >
+            open-source repo
+          </a>
+          .
+        </span>
+      ),
+    },
+  ];
+}
+
+function getStrategySettings(
+  settings: BoostedxSTRKCarryStrategySettings,
+  meta: { id: string; name: string; launchBlock: number },
+): IStrategyMetadata<BoostedxSTRKCarryStrategySettings> {
+  const depositToken = settings.depositToken;
+  const debtToken = settings.debtToken;
+  const lstToken = settings.lstHyperToken;
+
+  return {
+    id: meta.id,
+    name: meta.name,
+    description: `Deposits ${depositToken.symbol} as collateral on Vesu, borrows ${debtToken.symbol}, swaps to ${lstToken.symbol}, and deposits into Hyper-${lstToken.symbol} for boosted yield. Target LTV is about 50%, with rebalances happening when LTV is above 55%.`,
+    address: settings.vaultAddress,
+    launchBlock: meta.launchBlock,
+    type: "ERC4626" as const,
+    vaultType: {
+      type: VaultType.META_VAULT,
+      description: `Deposits ${depositToken.symbol} as collateral on Vesu, borrows ${debtToken.symbol}, swaps to ${lstToken.symbol}, and deposits into Hyper-${lstToken.symbol} for boosted yield`,
+    },
+    depositTokens: [depositToken],
+    additionalInfo: getBoostedxSTRKCarrySettings(settings),
+    risk: getBoostedCarryRisk(),
+    protocols: [Protocols.VESU, Protocols.ENDUR, Protocols.TROVES],
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png",
+    },
+    settings: {
+      maxTVL: Web3Number.fromWei(0, depositToken.decimals),
+      liveStatus: StrategyLiveStatus.HOT,
+      isPaused: false,
+      isAudited: true,
+      isInstantWithdrawal: false,
+      hideHarvestInfo: true,
+      quoteToken: depositToken,
+      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),
+    feeBps: {
+      performanceFeeBps: 1500,
+    },
+    faqs: getBoostedCarryFAQs(
+      depositToken.symbol,
+      debtToken.symbol,
+      lstToken.symbol,
+    ),
+    apyMethodology:
+      "APY reflects net returns performance fee on yield (not on principal). Underlying xSTRK appreciation and Vesu borrow costs can move over time; displayed APY is an estimate.",
+    investmentSteps: [
+      `Deposit ${depositToken.symbol} into the vault`,
+      `${depositToken.symbol} is supplied as collateral on Vesu, ${debtToken.symbol} is borrowed`,
+      `Borrowed ${debtToken.symbol} is swapped to ${lstToken.symbol} via Avnu`,
+      `${lstToken.symbol} is deposited into the Hyper-${lstToken.symbol} vault for additional yield`,
+      `Actively monitored and rebalanced to maintain optimal LTV and yield.`,
+    ],
+    // TODO: config later
+    tags: [StrategyTag.META_VAULT],
+    security: {
+      auditStatus: AuditStatus.AUDITED,
+      sourceCode: {
+        type: SourceCodeType.OPEN_SOURCE,
+        contractLink:
+          "https://github.com/trovesfi/starknet_vault_kit/tree/sherlock-audited",
+      },
+      // TODO
+      accessControl: {
+        type: AccessControlType.STANDARD_ACCOUNT,
+        addresses: [ContractAddr.from("0x0")],
+        timeLock: "0 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: "2 weeks",
+    usualTimeToEarningsDescription:
+      "This strategy depends on Hyper xSTRK's yield, which depends on the price of xSTRK on DEX appreciating. It may be possible the increase is not continuous and generally rebases atleast once every 2 weeks.",
+  };
+}
+
+export const BoostedxSTRKCarryStrategies: IStrategyMetadata<BoostedxSTRKCarryStrategySettings>[] =
+  [
+    getStrategySettings(boostedxSTRKCarrySettings, {
+      id: "usdc_boosted",
+      name: "USDC Boosted",
+      launchBlock: 10502825,
+    }),
+    getStrategySettings(wbtcBoostedSettings, {
+      id: "wbtc_boosted",
+      name: "WBTC Boosted",
+      launchBlock: 10502758,
+    }),
+  ];