@strkfarm/sdk 2.0.0-staging.7 → 2.0.0-staging.71

package/src/strategies/yoloVault.ts

@@ -0,0 +1,1084 @@
+import {
+  AccessControlType,
+  AuditStatus,
+  getNoRiskTags,
+  highlightTextWithLinks,
+  IConfig,
+  InstantWithdrawalVault,
+  IStrategyMetadata,
+  RiskFactor,
+  SourceCodeType,
+  StrategyLiveStatus,
+  TokenInfo,
+  UnwrapLabsCurator,
+  VaultPosition,
+  VaultType,
+} from "@/interfaces";
+import { logger } from "@/utils";
+import {
+  NetAPYDetails,
+  SingleActionAmount,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
+import {
+  BaseStrategy,
+  DualTokenInfo,
+} from "./base-strategy";
+import { BlockIdentifier, uint256, Uint256 } from "starknet";
+import { ContractAddr } from "@/dataTypes";
+import { Web3Number } from "@/dataTypes";
+import { DualActionAmount } from "./base-strategy";
+import { PricerBase } from "@/modules/pricerBase";
+import { Call, Contract } from "starknet";
+import ERC4626Abi from "@/data/erc4626.abi.json";
+import { Global } from "@/global";
+import { ERC20 } from "@/modules";
+import { MY_ACCESS_CONTROL } from "./constants";
+import { createElement } from "react";
+import { Token } from "graphql";
+
+export interface YoloVaultSettings {
+  startDate: string;
+  expiryDate: string;
+  mainToken: TokenInfo;
+  secondaryToken: TokenInfo;
+  totalEpochs: number;
+  minEpochDurationSeconds: number;
+  spendingLevels: YoloSpendingLevel[];
+  feeBps: number; // in bps
+  /** When true, base token is ERC-4626 (e.g. vUSDC); amounts for TVL / user info use `convert_to_assets` into `baseUnderlying`. */
+  isBaseERC4626?: boolean;
+  /** When true, second token is ERC-4626 (e.g. xSTRK); amounts use `convert_to_assets` into `secondUnderlying`. */
+  isSecondERC4626?: boolean;
+  /** Required when `isBaseERC4626` is true (e.g. USDC). */
+  baseUnderlying?: TokenInfo;
+  /** Required when `isSecondERC4626` is true (e.g. STRK / WBTC for xSTRK / xWBTC). */
+  secondUnderlying?: TokenInfo;
+}
+
+export interface YoloSpendingLevel {
+  minPrice?: number;
+  maxPrice?: number;
+  spendPercent: number;
+}
+
+interface YoloVaultStrategyConfig extends YoloVaultSettings {
+  id: string;
+  address: ContractAddr;
+  parent_id: string;
+  /** Higher shows earlier in UI. */
+  priority?: number;
+}
+
+export interface UserYoloInfo {
+  shares: bigint;
+  claimable_second_tokens: bigint;
+  base_token_balance: bigint;
+  base_token_consumed: bigint;
+  base_consumed_last_index: bigint;
+  second_token_last_index: bigint;
+  second_token_balance: bigint;
+}
+
+export interface YoloVaultStatus {
+  current_epoch: bigint;
+  total_epochs: bigint;
+  remaining_base: bigint;
+  total_second_tokens: bigint;
+  global_second_token_index: bigint;
+  cumulative_spend_index: bigint;
+  total_shares: bigint;
+  base_token_assets_per_share: bigint;
+}
+
+export interface YoloSettings {
+  base_token: bigint;
+  second_token: bigint;
+  total_epochs: bigint;
+  min_time_per_epoch: bigint;
+  max_spend_units_per_epoch: bigint;
+  base_token_assets_per_share: bigint;
+  oracle: bigint;
+}
+
+type YoloErc4626RuntimeConfig = {
+  isBaseERC4626: boolean;
+  isSecondERC4626: boolean;
+  baseUnderlying?: TokenInfo;
+  secondUnderlying?: TokenInfo;
+};
+
+export class YoLoVault extends BaseStrategy<DualTokenInfo, SingleActionAmount, DualActionAmount> {
+  readonly address: ContractAddr;
+  readonly metadata: IStrategyMetadata<YoloVaultSettings>;
+  readonly pricer: PricerBase;
+  /** Resolves to a `Contract` built from `provider.getClassAt` at the vault address (no checked-in vault ABI). */
+  readonly contract: Promise<Contract>;
+  readonly primaryToken : TokenInfo;
+  readonly secondaryToken : TokenInfo;
+  readonly erc4626: YoloErc4626RuntimeConfig;
+
+  constructor(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<YoloVaultSettings>,
+  ) {
+    super(config, {
+      depositInputMode: "single",
+      withdrawInputMode: "dual",
+    });
+    this.address = metadata.address;
+    this.pricer = pricer;
+    this.metadata = metadata;
+    this.contract = this.config.provider
+      .getClassAt(this.address.address)
+      .then(
+        (cls) =>
+          new Contract({
+            abi: cls.abi,
+            address: this.address.address,
+            providerOrAccount: this.config.provider,
+          }),
+      );
+
+    if (metadata.depositTokens.length < 1) {
+      throw new Error("Deposit tokens are not fully defined in metadata");
+    }
+    this.primaryToken = metadata.additionalInfo.mainToken;
+    this.secondaryToken = metadata.additionalInfo.secondaryToken;
+    const ai = metadata.additionalInfo;
+    this.erc4626 = {
+      isBaseERC4626: ai.isBaseERC4626 ?? false,
+      isSecondERC4626: ai.isSecondERC4626 ?? false,
+      baseUnderlying: ai.baseUnderlying,
+      secondUnderlying: ai.secondUnderlying,
+    };
+  }
+
+  /** Underlying (or base token) used for pricing / swap sell leg when base is ERC-4626. */
+  tokenForPrimaryPricing(): TokenInfo {
+    return this.erc4626.isBaseERC4626 && this.erc4626.baseUnderlying
+      ? this.erc4626.baseUnderlying
+      : this.primaryToken;
+  }
+
+  /** Underlying (or second token) for price ratios when second leg is ERC-4626 (e.g. STRK for xSTRK). */
+  tokenForSecondaryPricing(): TokenInfo {
+    return this.erc4626.isSecondERC4626 && this.erc4626.secondUnderlying
+      ? this.erc4626.secondUnderlying
+      : this.secondaryToken;
+  }
+
+  private primaryAmountDecimals(): number {
+    return this.erc4626.isBaseERC4626 && this.erc4626.baseUnderlying
+      ? this.erc4626.baseUnderlying.decimals
+      : this.primaryToken.decimals;
+  }
+
+  private secondaryAmountDecimals(): number {
+    return this.erc4626.isSecondERC4626 && this.erc4626.secondUnderlying
+      ? this.erc4626.secondUnderlying.decimals
+      : this.secondaryToken.decimals;
+  }
+
+  private async convertWrapperSharesToUnderlying(
+    wrapper: TokenInfo,
+    sharesRaw: bigint,
+    assetDecimals: number,
+    blockIdentifier: BlockIdentifier,
+  ): Promise<Web3Number> {
+    const wrapperContract = new Contract({
+      abi: ERC4626Abi,
+      address: wrapper.address.address,
+      providerOrAccount: this.config.provider,
+    });
+    const assets = await wrapperContract.call(
+      "convert_to_assets",
+      [uint256.bnToUint256(sharesRaw.toString())],
+      { blockIdentifier },
+    );
+    return Web3Number.fromWei(assets.toString(), assetDecimals);
+  }
+
+  // formatTokenAmount(amount: Web3Number, decimals: number): Web3Number {
+  //   const formattedAmount = amount.dividedBy(10 ** decimals);
+  //   return formattedAmount;
+  // }
+
+  private async getNormalizedUserInfo(user: ContractAddr, blockIdentifier: BlockIdentifier = "latest"): Promise<{
+    shares: Web3Number;
+    primaryTokenBalance: Web3Number;
+    secondaryTokenBalance: Web3Number;
+    claimableSecondaryTokens: Web3Number; 
+  }> {
+    const userInfo = await (await this.contract).call("get_user_info", [user.address], {
+      blockIdentifier,
+    });
+    const {
+      shares,
+      base_token_balance,
+      second_token_balance,
+      claimable_second_tokens,
+    } = userInfo as UserYoloInfo;
+    const userShares = new Web3Number(shares.toString(), 0);
+    const baseShares = base_token_balance;
+    const secondShares = second_token_balance;
+    const claimSecondShares = claimable_second_tokens;
+
+    let baseTokenBalance: Web3Number;
+    if (this.erc4626.isBaseERC4626 && this.erc4626.baseUnderlying) {
+      baseTokenBalance = await this.convertWrapperSharesToUnderlying(
+        this.primaryToken,
+        baseShares,
+        this.erc4626.baseUnderlying.decimals,
+        blockIdentifier,
+      );
+    } else {
+      baseTokenBalance = Web3Number.fromWei(baseShares.toString(), this.primaryToken.decimals);
+    }
+
+    let secondTokenBalance: Web3Number;
+    let claimableSecondTokens: Web3Number;
+    if (this.erc4626.isSecondERC4626 && this.erc4626.secondUnderlying) {
+      const assetDec = this.erc4626.secondUnderlying.decimals;
+      secondTokenBalance = await this.convertWrapperSharesToUnderlying(
+        this.secondaryToken,
+        secondShares,
+        assetDec,
+        blockIdentifier,
+      );
+      claimableSecondTokens = await this.convertWrapperSharesToUnderlying(
+        this.secondaryToken,
+        claimSecondShares,
+        assetDec,
+        blockIdentifier,
+      );
+    } else {
+      secondTokenBalance = Web3Number.fromWei(secondShares.toString(), this.secondaryToken.decimals);
+      claimableSecondTokens = Web3Number.fromWei(claimSecondShares.toString(), this.secondaryToken.decimals);
+    }
+
+    return {
+      shares: userShares,
+      primaryTokenBalance: baseTokenBalance,
+      secondaryTokenBalance: secondTokenBalance,
+      claimableSecondaryTokens: claimableSecondTokens,
+    };
+  }
+
+  private resolveWithdrawRequest(
+    amountInfo: DualActionAmount,
+    redeemableBaseTokenAmount: Web3Number,
+    redeemableSecondaryTokenAmount: Web3Number,
+  ):
+    | {
+        sharesUsedFactor: number;
+        baseTokenAmountToWithdraw: number;
+        secondaryTokenAmountToWithdraw: number;
+      }
+    | null {
+    const baseTokenAmountToWithdraw = Number(amountInfo.token0.amount.toWei());
+    const secondaryTokenAmountToWithdraw = Number(amountInfo.token1.amount.toWei());
+    // if (baseTokenAmountToWithdraw > 0 && secondaryTokenAmountToWithdraw > 0) {
+    //   throw new Error("Cannot pass amounts for both base and secondary tokens at once");
+    // }
+    if (
+      baseTokenAmountToWithdraw > 0 &&
+      redeemableBaseTokenAmount.greaterThanOrEqualTo(baseTokenAmountToWithdraw)
+    ) {
+      const sharesUsedFactor = new Web3Number(baseTokenAmountToWithdraw.toString(), 0).dividedBy(redeemableBaseTokenAmount);
+      return {
+        sharesUsedFactor: sharesUsedFactor.toNumber(),
+        baseTokenAmountToWithdraw,
+        secondaryTokenAmountToWithdraw,
+      };
+    }
+
+    if (
+      secondaryTokenAmountToWithdraw > 0 &&
+      redeemableSecondaryTokenAmount.greaterThanOrEqualTo(
+        secondaryTokenAmountToWithdraw,
+      )
+    ) {
+      const sharesUsedFactor = new Web3Number(secondaryTokenAmountToWithdraw.toString(), 0).dividedBy(redeemableSecondaryTokenAmount);
+      return {
+        sharesUsedFactor: sharesUsedFactor.toNumber(),
+        baseTokenAmountToWithdraw,
+        secondaryTokenAmountToWithdraw,
+      };
+    }
+
+    return null;
+  }
+
+  async getUserTVL(user: ContractAddr, blockIdentifier: BlockIdentifier = "latest"): Promise<DualTokenInfo> {
+    try {
+      const price0 = this.tokenForPrimaryPricing();
+      const price1 = this.tokenForSecondaryPricing();
+      const [{ primaryTokenBalance, claimableSecondaryTokens }, primaryTokenPrice, secondaryTokenPrice] = await Promise.all([
+        this.getNormalizedUserInfo(user, blockIdentifier),
+        this.pricer.getPrice(price0.symbol, blockIdentifier),
+        this.pricer.getPrice(price1.symbol, blockIdentifier),
+      ]);
+
+      // ! todo u can simply do primaryTokenAmount.multipliedBy(primaryTokenPrice.price).toNumber()
+      // leaving the other unchanged to help u see the diff
+      const primaryTokenUsd = primaryTokenBalance.multipliedBy(primaryTokenPrice.price).toNumber();
+      const secondaryTokenUsd =claimableSecondaryTokens.multipliedBy(secondaryTokenPrice.price);
+      return {
+        usdValue: primaryTokenUsd + secondaryTokenUsd.toNumber(),
+        token0: {
+          tokenInfo: price0,
+          amount: primaryTokenBalance,
+          usdValue: primaryTokenUsd,
+        },
+        token1: {
+          tokenInfo: price1,
+          amount: claimableSecondaryTokens,
+          usdValue: secondaryTokenUsd.toNumber(),
+        },
+      };
+    } catch (error) {
+      console.error("Error fetching user TVL:", error);
+      return {
+        usdValue: 0,
+        token0: {
+          tokenInfo: this.tokenForPrimaryPricing(),
+          amount: new Web3Number("0", this.primaryAmountDecimals()),
+          usdValue: 0,
+        },
+        token1: {
+          tokenInfo: this.tokenForSecondaryPricing(),
+          amount: new Web3Number("0", this.secondaryAmountDecimals()),
+          usdValue: 0,
+        },
+      };
+    }
+  }
+
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const vaultStatus = await this.getVaultStatus();
+    const {
+      remaining_base: remainingBase,
+      total_second_tokens: totalSecondTokens,
+    } = vaultStatus as YoloVaultStatus;
+    const baseShares = BigInt(remainingBase.toString());
+    const secondShares = BigInt(totalSecondTokens.toString());
+
+    let primaryTokenAmount: Web3Number;
+    if (this.erc4626.isBaseERC4626 && this.erc4626.baseUnderlying) {
+      primaryTokenAmount = await this.convertWrapperSharesToUnderlying(
+        this.primaryToken,
+        baseShares,
+        this.erc4626.baseUnderlying.decimals,
+        "latest",
+      );
+    } else {
+      primaryTokenAmount = Web3Number.fromWei(remainingBase.toString(), this.primaryToken.decimals);
+    }
+
+    let secondaryTokenAmount: Web3Number;
+    if (this.erc4626.isSecondERC4626 && this.erc4626.secondUnderlying) {
+      secondaryTokenAmount = await this.convertWrapperSharesToUnderlying(
+        this.secondaryToken,
+        secondShares,
+        this.erc4626.secondUnderlying.decimals,
+        "latest",
+      );
+    } else {
+      secondaryTokenAmount = Web3Number.fromWei(totalSecondTokens.toString(), this.secondaryToken.decimals);
+    }
+
+    const displayPrimary = this.tokenForPrimaryPricing();
+    const displaySecondary = this.tokenForSecondaryPricing();
+    const [primaryTokenPrice, secondaryTokenPrice] = await Promise.all([
+      this.pricer.getPrice(displayPrimary.symbol),
+      this.pricer.getPrice(displaySecondary.symbol),
+    ]);
+    const primaryTokenUsd = primaryTokenAmount.multipliedBy(primaryTokenPrice.price);
+    const secondaryTokenUsd = secondaryTokenAmount.multipliedBy(secondaryTokenPrice.price);
+    return [{
+      amount: primaryTokenAmount,
+      usdValue: primaryTokenUsd.toNumber(),
+      token: displayPrimary,
+      remarks: "Remaining deposit tokens in the Vault",
+    }, {
+      amount: secondaryTokenAmount,
+      usdValue: secondaryTokenUsd.toNumber(),
+      token: displaySecondary,
+      remarks: "Total swapped tokens in the Vault",
+    }]
+  }
+ 
+  async getTVL(): Promise<DualTokenInfo> {
+    try {
+      const displayPrimary = this.tokenForPrimaryPricing();
+      const displaySecondary = this.tokenForSecondaryPricing();
+      const [vaultStatus, primaryTokenPrice, secondaryTokenPrice] =
+        await Promise.all([
+          this.getVaultStatus(),
+          this.pricer.getPrice(displayPrimary.symbol),
+          this.pricer.getPrice(displaySecondary.symbol),
+        ]);
+      const {
+        remaining_base: remainingBase,
+        total_second_tokens: totalSecondTokens,
+      } = vaultStatus as YoloVaultStatus;
+
+      let primaryTokenAmount: Web3Number;
+      if (this.erc4626.isBaseERC4626 && this.erc4626.baseUnderlying) {
+        primaryTokenAmount = await this.convertWrapperSharesToUnderlying(
+          this.primaryToken,
+          BigInt(remainingBase.toString()),
+          this.erc4626.baseUnderlying.decimals,
+          "latest",
+        );
+      } else {
+        primaryTokenAmount = Web3Number.fromWei(remainingBase.toString(), this.primaryToken.decimals);
+      }
+
+      let secondaryTokenAmount: Web3Number;
+      if (this.erc4626.isSecondERC4626 && this.erc4626.secondUnderlying) {
+        secondaryTokenAmount = await this.convertWrapperSharesToUnderlying(
+          this.secondaryToken,
+          BigInt(totalSecondTokens.toString()),
+          this.erc4626.secondUnderlying.decimals,
+          "latest",
+        );
+      } else {
+        secondaryTokenAmount = Web3Number.fromWei(totalSecondTokens.toString(), this.secondaryToken.decimals);
+      }
+
+      const pDec = displayPrimary.decimals;
+      const sDec = displaySecondary.decimals;
+      const primaryTokenUsd = new Web3Number(
+        primaryTokenAmount.toFixed(pDec),
+        pDec,
+      ).multipliedBy(primaryTokenPrice.price);
+      const secondaryTokenUsd = new Web3Number(
+        secondaryTokenAmount.toFixed(sDec),
+        sDec,
+      ).multipliedBy(secondaryTokenPrice.price);
+
+      const totalUsdValue = primaryTokenUsd.plus(secondaryTokenUsd).toNumber();
+
+      if (
+        (totalUsdValue === 0 || primaryTokenAmount.eq(0) || secondaryTokenAmount.eq(0)) &&
+        this.metadata.settings?.liveStatus === StrategyLiveStatus.ACTIVE
+      ) {
+        logger.warn(
+          `${this.metadata.name}:getTVL - Zero value detected: ` +
+          `usdValue=${totalUsdValue}, ` +
+          `primaryTokenAmount=${primaryTokenAmount.toString()}, ` +
+          `secondaryTokenAmount=${secondaryTokenAmount.toString()}, ` +
+          `primaryTokenPrice=${primaryTokenPrice.price}, ` +
+          `secondaryTokenPrice=${secondaryTokenPrice.price}, ` +
+          `primaryTokenUsd=${primaryTokenUsd.toNumber()}, ` +
+          `secondaryTokenUsd=${secondaryTokenUsd.toNumber()}`
+        );
+      }
+
+      return {
+        usdValue: totalUsdValue,
+        token0: {
+          tokenInfo: displayPrimary,
+          amount: primaryTokenAmount,
+          usdValue: primaryTokenUsd.toNumber(),
+        },
+        token1: {
+          tokenInfo: displaySecondary,
+          amount: secondaryTokenAmount,
+          usdValue: secondaryTokenUsd.toNumber(),
+        },
+      };
+    } catch (error) {
+      console.error("Error fetching vault TVL:", error);
+      return {
+        usdValue: 0,
+        token0: {
+          tokenInfo: this.tokenForPrimaryPricing(),
+          amount: new Web3Number("0", this.primaryAmountDecimals()),
+          usdValue: 0,
+        },
+        token1: {
+          tokenInfo: this.tokenForSecondaryPricing(),
+          amount: new Web3Number("0", this.secondaryAmountDecimals()),
+          usdValue: 0,
+        },
+      };
+    }
+  }
+
+  async depositCall(
+    amountInfo: SingleActionAmount,
+    receiver: ContractAddr,
+  ): Promise<Call[]> {
+    try{
+      const vault = await this.contract;
+      if (this.erc4626.isBaseERC4626) {
+        if (!this.erc4626.baseUnderlying) {
+          throw new Error("baseUnderlying missing for ERC-4626 base YOLO vault");
+        }
+        const approvalCall = new ERC20(this.config).approve(
+          this.erc4626.baseUnderlying.address.address,
+          this.address.address,
+          amountInfo.amount,
+        );
+        const depositCall = vault.populate("deposit_combined", [
+          uint256.bnToUint256(amountInfo.amount.toWei()),
+          receiver.address,
+        ]);
+        return [approvalCall, depositCall];
+      }
+      const primaryToken = amountInfo.tokenInfo;
+      const approvalCall = new ERC20(this.config).approve(primaryToken.address.address, this.address.address, amountInfo.amount);
+      const depositCall = vault.populate("deposit", [
+          uint256.bnToUint256(amountInfo.amount.toWei()),
+          receiver.address,
+        ]);
+      return [approvalCall, depositCall];
+    }catch(err){
+      console.error("Error depositing:", err);
+      return [];
+    }
+  }
+
+  async getVaultStatus(): Promise<YoloVaultStatus> {
+    const vaultStatus = await (await this.contract).call("get_vault_status", []);
+    return vaultStatus as YoloVaultStatus;
+  }
+
+  async matchInputAmounts(
+    amountInfo: DualActionAmount,
+    user: ContractAddr,
+  ): Promise<DualActionAmount> {
+    let { primaryTokenBalance: redeemableBaseTokenAmount, claimableSecondaryTokens: redeemableSecondaryTokenAmount } =
+      await this.getNormalizedUserInfo(user);
+    redeemableBaseTokenAmount = new Web3Number(redeemableBaseTokenAmount.toWei().toString(), 0);
+    redeemableSecondaryTokenAmount = new Web3Number(redeemableSecondaryTokenAmount.toWei().toString(), 0);
+    const withdrawRequest = this.resolveWithdrawRequest(
+      amountInfo,
+      redeemableBaseTokenAmount,
+      redeemableSecondaryTokenAmount,
+    );
+
+    if (!withdrawRequest) {
+      throw new Error("Invalid amount info");
+    }
+
+    const {
+      sharesUsedFactor,
+      baseTokenAmountToWithdraw,
+      secondaryTokenAmountToWithdraw,
+    } = withdrawRequest;
+
+    if (baseTokenAmountToWithdraw > 0) {
+      const secondaryTokenAmount = redeemableSecondaryTokenAmount.dividedBy(10 ** this.secondaryAmountDecimals()).multipliedBy(sharesUsedFactor);
+      return {
+        token0: {
+          tokenInfo: amountInfo.token0.tokenInfo,
+          amount: new Web3Number(baseTokenAmountToWithdraw.toString(), 0),
+        },
+        token1: {
+          tokenInfo: amountInfo.token1.tokenInfo,
+          amount: secondaryTokenAmount,
+        },
+      };
+    }
+    
+    const baseTokenAmount = redeemableBaseTokenAmount.dividedBy(10 ** this.primaryAmountDecimals()).multipliedBy(sharesUsedFactor);
+    return {
+      token0: {
+        tokenInfo: amountInfo.token0.tokenInfo,
+        amount: baseTokenAmount,
+      },
+      token1: {
+        tokenInfo: amountInfo.token1.tokenInfo,
+        amount: new Web3Number(secondaryTokenAmountToWithdraw.toString(), 0),
+      },
+    };
+  }
+
+  async withdrawCall(
+    amountInfo: DualActionAmount,
+    receiver: ContractAddr,
+    owner: ContractAddr,
+  ): Promise<Call[]> {
+    try{
+    let {
+      shares: userShares,
+      primaryTokenBalance: redeemableBaseTokenAmount,
+      claimableSecondaryTokens: redeemableSecondaryTokenAmount,
+    } = await this.getNormalizedUserInfo(receiver);
+    redeemableBaseTokenAmount = new Web3Number(redeemableBaseTokenAmount.toWei().toString(), 0);
+    redeemableSecondaryTokenAmount = new Web3Number(redeemableSecondaryTokenAmount.toWei().toString(), 0);
+    const withdrawRequest = this.resolveWithdrawRequest(
+      amountInfo,
+      redeemableBaseTokenAmount,
+      redeemableSecondaryTokenAmount,
+    );
+   
+    if (!withdrawRequest) {
+      throw new Error("Invalid amount info");
+    }
+    const requiredShares =  userShares.multipliedBy(withdrawRequest.sharesUsedFactor).floor();
+    const redeemFn = this.erc4626.isBaseERC4626 ? "redeem_combined" : "redeem";
+    const vault = await this.contract;
+    let withdrawCall = vault.populate(redeemFn, [
+      uint256.bnToUint256(requiredShares.toString()),
+      receiver.address,
+    ]);
+    return [withdrawCall];
+    }catch(err){
+      console.error("Error withdrawing:", err);
+      return [];
+    }
+  }
+
+  async netAPY(): Promise<number | string | NetAPYDetails> {
+    return "🤙YOLO"
+  }
+
+  async getSwapAmounts(spendUnits: Web3Number): Promise<{ grossSpend: Web3Number; netSpend: Web3Number; isReadyForNextSwap: boolean }> {
+    const swapAmounts: any = await (await this.contract).call("get_swap_amounts", [spendUnits.toUint256()]);
+    console.log("swapAmounts", swapAmounts);
+    return {
+      grossSpend: Web3Number.fromWei(swapAmounts[0].toString(), this.primaryToken.decimals),
+      netSpend: Web3Number.fromWei(swapAmounts[1].toString(), this.primaryToken.decimals),
+      isReadyForNextSwap: swapAmounts[2] as boolean,
+    };
+  }
+
+  getSettings = async (): Promise<YoloSettings> => {
+    const settings = await (await this.contract).call("get_settings", []);
+    return settings as YoloSettings;
+  };
+
+  async getMaxTVL(): Promise<Web3Number> {
+    // Simply returning a fixed value for now, can automate later as per req
+    return new Web3Number("200000", 6);
+  }
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const userTVL = await this.getUserTVL(input.user);
+    const holdingsTitle = `${this.tokenForPrimaryPricing().symbol} Left`;
+    const earningsTitle = `${this.tokenForSecondaryPricing().symbol} Accumulated`;
+    const cards: UserPositionCard[] = [
+      {
+        title: "Your Holdings",
+        tooltip: "Combined value of your remaining base token and accumulated secondary token",
+        value: this.formatUSDForCard(userTVL.usdValue),
+      },
+      {
+        title: holdingsTitle,
+        tooltip: `Amount of ${this.tokenForPrimaryPricing().symbol} left in the vault, waiting to be swapped`,
+        value: this.formatTokenAmountForCard(userTVL.token0.amount, userTVL.token0.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.token0.usdValue)}`,
+        subValueColor: "positive",
+      },
+      {
+        title: earningsTitle,
+        tooltip: `Amount of ${this.tokenForSecondaryPricing().symbol} accumulated in the vault`,
+        value: this.formatTokenAmountForCard(userTVL.token1.amount, userTVL.token1.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.token1.usdValue)}`,
+        subValueColor: "default",
+      },
+    ];
+    return cards;
+  }
+}
+
+const formatPriceLabel = (price: number): string => {
+  return `${price.toLocaleString("en-US")}`;
+};
+
+const formatDurationSeconds = (seconds: number): string => {
+  return `${Math.floor(seconds / 3600).toLocaleString("en-US")} hours`;
+};
+
+const getLevelRangeLabel = (
+  level: YoloSpendingLevel,
+  secondaryTokenSymbol: string,
+): string => {
+  if (level.minPrice !== undefined && level.maxPrice !== undefined) {
+    return `${formatPriceLabel(level.minPrice)}-${formatPriceLabel(level.maxPrice)} ${secondaryTokenSymbol}`;
+  }
+  if (level.minPrice !== undefined) {
+    return `>= ${formatPriceLabel(level.minPrice)} ${secondaryTokenSymbol}`;
+  }
+  return `< ${formatPriceLabel(level.maxPrice!)} ${secondaryTokenSymbol}`;
+};
+
+const getSpendingLevelRows = (
+  levels: YoloSpendingLevel[],
+  secondaryTokenSymbol: string,
+): Array<{ range: string; multiplier: string }> => {
+  const positiveSpends = levels.map((l) => l.spendPercent).filter((v) => v > 0);
+  const minSpendPercent = positiveSpends.length > 0 ? Math.min(...positiveSpends) : 1;
+
+  return levels.map((level) => {
+    const multiplier = level.spendPercent > 0 ? level.spendPercent / minSpendPercent : 0;
+    return {
+      range: getLevelRangeLabel(level, secondaryTokenSymbol),
+      multiplier: `${multiplier.toFixed(2)}x`,
+    };
+  });
+};
+
+const getYoloVaultCopy = (input: YoloVaultSettings) => {
+  const main = input.mainToken.symbol;
+  const secondary = input.secondaryToken.symbol;
+  const spendingRows = getSpendingLevelRows(input.spendingLevels, secondary);
+  const description = createElement(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        gap: "12px",
+      },
+    },
+    createElement(
+      "p",
+      null,
+      `Troves Value Averaging (TVA) vault for ${main} -> ${secondary} accumulation.`
+    ),
+    createElement(
+      "p",
+      null,
+      `We're all bullish on ${secondary}. Price only dips to hit new ATHs in the next cycle. This vault helps you prep - degen style. After all, YOLO.`
+    ),
+    createElement("p", null, createElement("strong", null, "Start Date: "), input.startDate),
+    createElement("p", null, createElement("strong", null, "Expiry Date: "), input.expiryDate),
+    createElement(
+      "p",
+      null,
+      createElement("strong", null, "Execution Window: "),
+      `${input.totalEpochs} epochs, minimum ${formatDurationSeconds(input.minEpochDurationSeconds)} per epoch`
+    ),
+    createElement(
+      "p",
+      null,
+      createElement("strong", null, "TVA Edge vs DCA: "),
+      "deploys more aggressively into dips and stays measured when prices are high."
+    ),
+    createElement("div", null, createElement("strong", null, "Spend Levels: ")),
+    createElement(
+      "div",
+      {
+        style: {
+          display: "grid",
+          gridTemplateColumns: "2fr 1fr",
+          gap: "4px 12px",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+          fontSize: "12px",
+          lineHeight: "18px",
+          padding: "8px 10px",
+          borderRadius: "8px",
+          background: "rgba(255,255,255,0.04)",
+        },
+      },
+      createElement("strong", { key: "h-range" }, "Range"),
+      createElement("strong", { key: "h-mult" }, "Multiplier"),
+      ...spendingRows.flatMap((row, idx) => [
+        createElement("span", { key: `r-${idx}` }, row.range),
+        createElement("span", { key: `m-${idx}` }, row.multiplier),
+      ])
+    ),
+    createElement(
+      "p",
+      null,
+      "Learn the core ",
+      highlightTextWithLinks("value averaging", [
+        {
+          highlight: "value averaging",
+          link: "https://www.investopedia.com/terms/v/value_averaging.asp",
+        },
+      ]),
+      " concept."
+    )
+  );
+  const vaultTypeDescription =
+    `Troves Value Averaging (TVA) vault to accumulate ${secondary} from ${main} using level-based buying until ${input.expiryDate}.`;
+  const faqs = [
+    {
+      question: `What is this ${secondary} TVA vault?`,
+      answer:
+        `You deposit ${main}, and troves executes epoch swaps to accumulate ${secondary} based on configured spend levels until ${input.expiryDate}.`,
+    },
+    {
+      question: `Why TVA instead of standard DCA?`,
+      answer:
+        "TVA increases buying intensity as price drops and can stay conservative at higher prices. This dynamic schedule can outperform fixed-size DCA in volatile markets.",
+    },
+    {
+      question: `When does this vault expire (${input.expiryDate})?`,
+      answer:
+        `The active schedule starts on ${input.startDate}, runs for ${input.totalEpochs} epochs, and each epoch needs at least ${formatDurationSeconds(input.minEpochDurationSeconds)} before the next execution.`,
+    },
+    {
+      question: "How are spend levels applied?",
+      answer:
+        `Each epoch uses a spend band from 0-100% of allowed units based on ${secondary}/${main} market conditions. Lower the price, higher the spend percentage.`,
+    },
+    {
+      question: "How do withdrawals work?",
+      answer:
+        `Redemption returns your pro-rata remaining ${main} and accumulated ${secondary} based on shares.`,
+    },
+    {
+      question: "Is this strategy audited and open source?",
+      answer:
+        "Not yet. The strategy is currently not audited and the code is closed source.",
+    },
+    {
+      question: "What are the fees in this vault?",
+      answer:
+        "This Vault has two fees: Swap fee (0.5%) (similar to management fee) and Performance fee (10%). Swap fee covers execution and routing costs each epoch. Performance fee applies only when exits are in profit. If TVL scales, fee reduction or removal is on the table.",
+    },
+  ];
+  const investmentSteps = [
+    `Deposit ${main} after start (${input.startDate}) and before expiry (${input.expiryDate}).`,
+    `Each epoch (minimum ${formatDurationSeconds(input.minEpochDurationSeconds)}), troves swaps into ${secondary} based on the configured spending level.`,
+    `Lower prices can trigger higher spend percentages (TVA behavior).`,
+    `Redeem any time to receive your remaining ${main} plus accumulated ${secondary}.`,
+    `On expiry, entire ${main} token would have been swapped into ${secondary}, unless due to unfavourable market conditions.`
+  ];
+
+  const parentTitle = secondary.replace('x', '');
+  const variantIntro = {
+    title: `${parentTitle} YOLO vault variant`,
+    description:
+      "Each variant runs until a different expiry date. TVA schedules and execution windows are configured per vault.",
+  };
+
+  return {
+    title: `${parentTitle} YOLO (${input.expiryDate})`,
+    description,
+    vaultTypeDescription,
+    faqs,
+    investmentSteps,
+    parentTitle: `${parentTitle} YOLO`,
+    variantIntro,
+  };
+};
+
+const usdc = Global.getDefaultTokens().find((t) => t.symbol === "USDC")!;
+const wbtc = Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!;
+const xSTRK = Global.getDefaultTokens().find((t) => t.symbol === "xSTRK")!;
+const xWBTC = Global.getDefaultTokens().find((t) => t.symbol === "xWBTC")!;
+const vesuPrimeUSDC: TokenInfo = {
+  address: ContractAddr.from("0x00387e8ddbb1ab36ca08874d9abc702ef4872ad600dcf76b7f240b71d7bc4e65"),
+  symbol: "vUSDC",
+  name: "Vesu Prime USDC",
+  decimals: 18,
+  logo: usdc.logo,
+  displayDecimals: 2,
+};
+
+const strk = Global.getDefaultTokens().find((t) => t.symbol === "STRK")!;
+
+function getYoloVaultErc4626Config(mainToken: TokenInfo, secondaryToken: TokenInfo): {
+  isBaseERC4626: boolean;
+  isSecondERC4626: boolean;
+  baseUnderlying?: TokenInfo;
+  secondUnderlying?: TokenInfo;
+} {
+  const isVesuPrime =
+    mainToken.address.address.toLowerCase() === vesuPrimeUSDC.address.address.toLowerCase();
+  if (isVesuPrime && secondaryToken.symbol.startsWith("x")) {
+    const secondUnderlying =
+      secondaryToken.symbol === "xWBTC"
+        ? wbtc
+        : secondaryToken.symbol === "xSTRK"
+          ? strk
+          : undefined;
+    if (!secondUnderlying) {
+      throw new Error(
+        `YOLO vault: unsupported x-token ${secondaryToken.symbol} for Vesu Prime USDC pair`,
+      );
+    }
+    return {
+      isBaseERC4626: true,
+      isSecondERC4626: true,
+      baseUnderlying: usdc,
+      secondUnderlying,
+    };
+  }
+  return {
+    isBaseERC4626: false,
+    isSecondERC4626: false,
+  };
+}
+
+const vaultCommonProperties = {
+  totalEpochs: 1206407,
+  minEpochDurationSeconds: 21600,
+  feeBps: 50,
+  spendingLevels: [
+    { minPrice: 80000, maxPrice: 100000, spendPercent: 50 },
+    { minPrice: 70000, maxPrice: 80000, spendPercent: 70 },
+    { minPrice: 60000, maxPrice: 70000, spendPercent: 100 },
+    { minPrice: 50000, maxPrice: 60000, spendPercent: 250 },
+    { maxPrice: 50000, spendPercent: 500 },
+  ],
+};
+
+const wbtc_parent = "wbtc-yolo";
+const xstrk_parent = "xstrk-yolo";
+
+const yoloVaultsConfig:YoloVaultStrategyConfig[] = [
+  {
+    address: ContractAddr.from("0x018ccdff25a642e211f86ace35ba282ebdf342330319ead98cae37258bc9cce1"),
+    mainToken: usdc,
+    secondaryToken: wbtc,
+    startDate: "03-MAR-2026",
+    expiryDate: "31-DEC-2026",
+    id: `btc-yolo-31-dec-2026`,
+    priority: 100,
+    ...vaultCommonProperties,
+    parent_id: wbtc_parent,
+  },
+  // {
+  //   address: ContractAddr.from("0x3381380c6cca17c2a20e1167a362d5b939e392311cbcdf2016f9c7c7a23a801"),
+  //   mainToken: vesuPrimeUSDC,
+  //   secondaryToken: xWBTC,
+  //   startDate: "03-APR-2026",
+  //   expiryDate: "31-MAY-2026",
+  //   id: `vusdc-xwbct-yolo-31-may-2026`,
+  //   priority: 100,
+  //   ...vaultCommonProperties,
+  //   parent_id: wbtc_parent
+  // },
+  // {
+  //   address: ContractAddr.from("0x60c8466549a8e51eed0e8c38243fdb57d173c96cfdd4375b49ad1e338ff893"),
+  //   mainToken: vesuPrimeUSDC,
+  //   secondaryToken: xSTRK,
+  //   startDate: "03-APR-2026",
+  //   expiryDate: "31-MAR-2027",
+  //   id: `xstrk-yolo-31-mar-2027`,
+  //   priority: 50,
+  //   ...vaultCommonProperties,
+  //   spendingLevels: [
+  //     { minPrice: 0.07, maxPrice: 0.1, spendPercent: 50 },
+  //     { minPrice: 0.06, maxPrice: 0.07, spendPercent: 70 },
+  //     { minPrice: 0.04, maxPrice: 0.06, spendPercent: 100 },
+  //     { minPrice: 0.025, maxPrice: 0.04, spendPercent: 250 },
+  //     { maxPrice: 0.025, spendPercent: 500 },
+  //   ],
+  //   parent_id: xstrk_parent
+  // },
+  // {
+  //   address: ContractAddr.from("0x62499970196772c18ccf1da09910ece11d85d5df3e8f6d6e41b4d158fcb8e79"),
+  //   mainToken: vesuPrimeUSDC,
+  //   secondaryToken: xSTRK,
+  //   startDate: "03-APR-2026",
+  //   expiryDate: "30-JUN-2026",
+  //   id: `xstrk-yolo-30-jun-2026`,
+  //   priority: 50,
+  //   ...vaultCommonProperties,
+  //   spendingLevels: [
+  //     { minPrice: 0.07, maxPrice: 0.1, spendPercent: 50 },
+  //     { minPrice: 0.06, maxPrice: 0.07, spendPercent: 70 },
+  //     { minPrice: 0.04, maxPrice: 0.06, spendPercent: 100 },
+  //     { minPrice: 0.025, maxPrice: 0.04, spendPercent: 250 },
+  //     { maxPrice: 0.025, spendPercent: 500 },
+  //   ],
+  //   parent_id: xstrk_parent
+  // }
+]
+
+// Risk factors intentionally left unrated for this strategy for now.
+// const yoloRiskFactors: RiskFactor[] = [ ... ];
+const yoloRiskFactors: RiskFactor[] = [];
+
+export const YoloVaultStrategies: IStrategyMetadata<YoloVaultSettings>[] = yoloVaultsConfig.map(yoloConfig => {
+  const yoloCopy = getYoloVaultCopy(yoloConfig);
+  const erc4626Cfg = getYoloVaultErc4626Config(yoloConfig.mainToken, yoloConfig.secondaryToken);
+  return {
+    id: yoloConfig.id,
+    name: yoloCopy.title,
+    parentName: yoloCopy.parentTitle,
+    parentId: yoloConfig.parent_id,
+    priority: yoloConfig.priority,
+    variantIntro: yoloCopy.variantIntro,
+    description: yoloCopy.description,
+    address: yoloConfig.address,
+    vaultType: {
+      type: VaultType.TVA,
+      description: yoloCopy.vaultTypeDescription,
+    },
+    curator: UnwrapLabsCurator,
+    security: {
+      auditStatus: AuditStatus.NOT_AUDITED,
+      sourceCode: {
+        type: SourceCodeType.CLOSED_SOURCE,
+        contractLink: "",
+      },
+      accessControl: {
+        type: AccessControlType.ROLE_BASED_ACCESS,
+        addresses: [MY_ACCESS_CONTROL.address],
+      },
+    },
+    redemptionInfo: {
+      instantWithdrawalVault: InstantWithdrawalVault.YES,
+      redemptionsInfo: [],
+      alerts: [],
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null,
+    launchBlock: 0,
+    type: "Other",
+    depositTokens: [
+      usdc,
+      yoloConfig.secondaryToken,
+    ],
+    protocols: [],
+    risk: {
+      riskFactor: yoloRiskFactors,
+      netRisk: 0,
+      notARisks: getNoRiskTags(yoloRiskFactors),
+    },
+    apyMethodology:
+      "Not a primary yield strategy. Funds earn yield when idle, but the main return comes from BTC price appreciation and your conviction to hold. This vault simply helps you accumulate more BTC.",
+    feeBps: {
+      performanceFeeBps: 1000,
+    },
+    additionalInfo: {
+      mainToken: yoloConfig.mainToken,
+      secondaryToken: yoloConfig.secondaryToken,
+      startDate: yoloConfig.startDate,
+      expiryDate: yoloConfig.expiryDate,
+      totalEpochs: yoloConfig.totalEpochs,
+      minEpochDurationSeconds: yoloConfig.minEpochDurationSeconds,
+      spendingLevels: yoloConfig.spendingLevels,
+      feeBps: yoloConfig.feeBps, // swap fee bps
+      isBaseERC4626: erc4626Cfg.isBaseERC4626,
+      isSecondERC4626: erc4626Cfg.isSecondERC4626,
+      ...(erc4626Cfg.isBaseERC4626 && erc4626Cfg.baseUnderlying && erc4626Cfg.secondUnderlying
+        ? {
+            baseUnderlying: erc4626Cfg.baseUnderlying,
+            secondUnderlying: erc4626Cfg.secondUnderlying,
+          }
+        : {}),
+    },
+    faqs: yoloCopy.faqs,
+    contractDetails: [{name: "Vault", address: yoloConfig.address}],
+    investmentSteps: yoloCopy.investmentSteps,
+    settings: {
+      liveStatus: StrategyLiveStatus.HOT,
+      isAudited: false,
+      quoteToken:
+        erc4626Cfg.isBaseERC4626 && erc4626Cfg.baseUnderlying
+          ? erc4626Cfg.baseUnderlying
+          : yoloConfig.mainToken,
+      isTransactionHistDisabled: true,
+    },
+    apyHistoryUIConfig: {
+      showApyHistory: false,
+      noApyHistoryMessage:
+        "APY history is hidden because this is a TVA accumulation vault, not a yield-bearing APY strategy.",
+    },
+  }
+});