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

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

@@ -0,0 +1,1057 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Global } from "@/global";
+import {
+  AccessControlType,
+  AuditStatus,
+  getMainnetConfig,
+  IConfig,
+  InstantWithdrawalVault,
+  IStrategyMetadata,
+  Protocols,
+  SourceCodeType,
+  StrategyTag,
+  TokenInfo,
+  VaultPosition,
+  VaultType,
+} from "@/interfaces";
+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 } 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 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(
+    "0xcdb0e3b2e076a2cdc4ee958b726b47c066239ef91c5ac80c94cf814147b84",
+  ),
+  manager: ContractAddr.from(
+    "0x72eea9bac9fa8cfffda637d3b990851446860c6fd8987d6cb50e659b01ee50f",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x6d3101cff7f821412a99ebe23bb31a1950f93276285102eb4313e3601f5f927",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x47dcc6889ca8db4e9eea8f55421e10f8ce7e356ccb45260a1c49a76f733c309",
+  ),
+  // 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.32,
+  // Calc using the maxLTV / maxAcceptableLTV (0.55)
+  minHealthFactor: 1.2,
+  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.66,
+  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(
+    "0x69e081304917cbf2d39772483aa8b4b389c1a55d658493b28139e921cf83b6",
+  ),
+  manager: ContractAddr.from(
+    "0x1936da7771d657fa6c41a2c6a7b64f7fc9c88782098f537ea4180263930f9a8",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x68008fce59ad4dfb63cc293f7bf020d12902957ea85f95c4e1c1e98f415b668",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x1ed34e1a94ca6dd766ded6f207c67a3857ea489d16b42cd03403c5071f131c7",
+  ),
+  aumOracle: ContractAddr.from(
+    "0xed774c6484dba664354ebaa1c993a37e9ad4c14870cda0762ae0194caed056",
+  ),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.32,
+  minHealthFactor: 1.2,
+  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.66,
+  targetLTV: 0.5,
+  hasBtcFiRewards: true,
+  hyperLstVaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960",
+  ),
+  hyperLstRedeemNFT: ContractAddr.from(
+    "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095",
+  ),
+  trovesStrategyId: "hyper_xstrk",
+};
+
+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`,
+    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),
+    // 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, depositToken.decimals),
+      isPaused: false,
+      isAudited: false,
+      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),
+    // TODO: config later
+    faqs: [],
+    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`,
+      `On withdrawal, the pipeline reverses to return ${depositToken.symbol}`,
+    ],
+    // 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,
+  };
+}
+
+// TODO: rename to BoostedCollateralStrategies later on or smthin
+export const BoostedxSTRKCarryStrategies: IStrategyMetadata<BoostedxSTRKCarryStrategySettings>[] =
+  [
+    getStrategySettings(boostedxSTRKCarrySettings, {
+      id: "usdc_boosted",
+      name: "USDC Boosted",
+      launchBlock: 8742931,
+    }),
+    getStrategySettings(wbtcBoostedSettings, {
+      id: "wbtc_boosted",
+      name: "WBTC Boosted",
+      launchBlock: 9803209,
+    }),
+  ];