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

package/src/strategies/yoloVault.ts

@@ -0,0 +1,747 @@
+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 { 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 YoloVaultAbi from "@/data/yoloVault.abi.json";
+import { Global } from "@/global";
+import { ERC20 } from "@/modules";
+import { MY_ACCESS_CONTROL } from "./constants";
+import { createElement } from "react";
+
+export interface YoloVaultSettings {
+  startDate: string;
+  expiryDate: string;
+  mainToken: TokenInfo;
+  secondaryToken: TokenInfo;
+  totalEpochs: number;
+  minEpochDurationSeconds: number;
+  spendingLevels: YoloSpendingLevel[];
+  feeBps: number; // in bps
+}
+
+export interface YoloSpendingLevel {
+  minPrice?: number;
+  maxPrice?: number;
+  spendPercent: number;
+}
+
+interface YoloVaultStrategyConfig extends YoloVaultSettings {
+  id: string;
+  address: ContractAddr;
+}
+
+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;
+}
+
+export class YoLoVault extends BaseStrategy<DualTokenInfo, SingleActionAmount, DualActionAmount> {
+  readonly address: ContractAddr;
+  readonly metadata: IStrategyMetadata<YoloVaultSettings>;
+  readonly pricer: PricerBase;
+  readonly contract: Contract;
+  readonly primaryToken : TokenInfo;
+  readonly secondaryToken : TokenInfo;
+
+  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 = new Contract({
+      abi: YoloVaultAbi,
+      address: this.address.address,
+      providerOrAccount: this.config.provider,
+    });
+
+    if (metadata.depositTokens.length < 2) {
+      throw new Error("Deposit tokens are not fully defined in metadata");
+    }
+    this.primaryToken = metadata.depositTokens[0];
+    this.secondaryToken = metadata.depositTokens[1];
+  }
+
+
+  // formatTokenAmount(amount: Web3Number, decimals: number): Web3Number {
+  //   const formattedAmount = amount.dividedBy(10 ** decimals);
+  //   return formattedAmount;
+  // }
+
+  private async getNormalizedUserInfo(user: ContractAddr): Promise<{
+    shares: Web3Number;
+    primaryTokenBalance: Web3Number;
+    secondaryTokenBalance: Web3Number;
+    claimableSecondaryTokens: Web3Number; 
+  }> {
+    const userInfo = await this.contract.call("get_user_info", [user.address]);
+    const {
+      shares,
+      base_token_balance,
+      second_token_balance,
+      claimable_second_tokens,
+    } = userInfo as UserYoloInfo;
+    const userShares = new Web3Number(shares.toString(), 0);
+    const baseTokenBalance = Web3Number.fromWei(base_token_balance.toString(), this.primaryToken.decimals);
+    const secondTokenBalance = Web3Number.fromWei(second_token_balance.toString(), this.secondaryToken.decimals);
+    const claimableSecondTokens = Web3Number.fromWei(claimable_second_tokens.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): Promise<DualTokenInfo> {
+    try {
+      const [{ primaryTokenBalance, claimableSecondaryTokens }, primaryTokenPrice, secondaryTokenPrice] = await Promise.all([
+        this.getNormalizedUserInfo(user),
+        this.pricer.getPrice(this.primaryToken.symbol),
+        this.pricer.getPrice(this.secondaryToken.symbol),
+      ]);
+
+      // ! 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: this.primaryToken,
+          amount: primaryTokenBalance,
+          usdValue: primaryTokenUsd,
+        },
+        token1: {
+          tokenInfo: this.secondaryToken,
+          amount: claimableSecondaryTokens,
+          usdValue: secondaryTokenUsd.toNumber(),
+        },
+      };
+    } catch (error) {
+      console.error("Error fetching user TVL:", error);
+      return {
+        usdValue: 0,
+        token0: {
+          tokenInfo: this.primaryToken,
+          amount: new Web3Number("0", this.primaryToken.decimals),
+          usdValue: 0,
+        },
+        token1: {
+          tokenInfo: this.secondaryToken,
+          amount: new Web3Number("0", this.secondaryToken.decimals),
+          usdValue: 0,
+        },
+      };
+    }
+  }
+
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const vaultStatus = await this.getVaultStatus();
+    const {
+      remaining_base: remainingBase,
+      total_second_tokens: totalSecondTokens,
+    } = vaultStatus as YoloVaultStatus;
+    const primaryTokenAmount = Web3Number.fromWei(remainingBase.toString(), this.primaryToken.decimals);
+    const secondaryTokenAmount = Web3Number.fromWei(totalSecondTokens.toString(), this.secondaryToken.decimals);
+    const [primaryTokenPrice, secondaryTokenPrice] = await Promise.all([
+      this.pricer.getPrice(this.primaryToken.symbol),
+      this.pricer.getPrice(this.secondaryToken.symbol),
+    ]);
+    const primaryTokenUsd = primaryTokenAmount.multipliedBy(primaryTokenPrice.price);
+    const secondaryTokenUsd = secondaryTokenAmount.multipliedBy(secondaryTokenPrice.price);
+    return [{
+      amount: primaryTokenAmount,
+      usdValue: primaryTokenUsd.toNumber(),
+      token: this.primaryToken,
+      remarks: "Remaining deposit tokens in the Vault",
+    }, {
+      amount: secondaryTokenAmount,
+      usdValue: secondaryTokenUsd.toNumber(),
+      token: this.secondaryToken,
+      remarks: "Total swapped tokens in the Vault",
+    }]
+  }
+ 
+  async getTVL(): Promise<DualTokenInfo> {
+    try {
+      const [vaultStatus, primaryTokenPrice, secondaryTokenPrice] =
+        await Promise.all([
+          this.getVaultStatus(),
+          this.pricer.getPrice(this.primaryToken.symbol),
+          this.pricer.getPrice(this.secondaryToken.symbol),
+        ]);
+      const {
+        remaining_base: remainingBase,
+        total_second_tokens: totalSecondTokens,
+      } = vaultStatus as YoloVaultStatus;
+     
+      let primaryTokenAmount = Web3Number.fromWei(remainingBase.toString(), this.primaryToken.decimals);
+      let secondaryTokenAmount = Web3Number.fromWei(totalSecondTokens.toString(), this.secondaryToken.decimals);
+      const primaryTokenUsd = new Web3Number(
+        primaryTokenAmount.toFixed(this.primaryToken.decimals),
+        this.primaryToken.decimals,
+      ).multipliedBy(primaryTokenPrice.price);
+      const secondaryTokenUsd = new Web3Number(
+        secondaryTokenAmount.toFixed(this.secondaryToken.decimals),
+        this.secondaryToken.decimals,
+      ).multipliedBy(secondaryTokenPrice.price);
+
+      return {
+        usdValue: primaryTokenUsd.plus(secondaryTokenUsd).toNumber(),
+        token0: {
+          tokenInfo: this.primaryToken,
+          amount: primaryTokenAmount,
+          usdValue: primaryTokenUsd.toNumber(),
+        },
+        token1: {
+          tokenInfo: this.secondaryToken,
+          amount: secondaryTokenAmount,
+          usdValue: secondaryTokenUsd.toNumber(),
+        },
+      };
+    } catch (error) {
+      console.error("Error fetching vault TVL:", error);
+      return {
+        usdValue: 0,
+        token0: {
+          tokenInfo: this.primaryToken,
+          amount: new Web3Number("0", this.primaryToken.decimals),
+          usdValue: 0,
+        },
+        token1: {
+          tokenInfo: this.secondaryToken,
+          amount: new Web3Number("0", this.secondaryToken.decimals),
+          usdValue: 0,
+        },
+      };
+    }
+  }
+
+  async depositCall(
+    amountInfo: SingleActionAmount,
+    receiver: ContractAddr,
+  ): Promise<Call[]> {
+    try{
+      const primaryToken = amountInfo.tokenInfo;
+      const approvalCall = new ERC20(this.config).approve(primaryToken.address.address, this.address.address, amountInfo.amount);
+      const depositCall = this.contract.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 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.secondaryToken.decimals).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.primaryToken.decimals).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();
+    let withdrawCall = this.contract.populate("redeem", [
+      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 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 this.contract.call("get_settings", []);
+    return settings as YoloSettings;
+  };
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const userTVL = await this.getUserTVL(input.user);
+    const holdingsTitle = `${this.primaryToken.symbol} Left`;
+    const earningsTitle = `${this.secondaryToken.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),
+        subValue: `${holdingsTitle} + ${earningsTitle}`,
+        subValueColor: "positive",
+      },
+      {
+        title: holdingsTitle,
+        tooltip: `Amount of ${this.primaryToken.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.secondaryToken.symbol} accumulated in the vault`,
+        value: this.formatTokenAmountForCard(userTVL.token1.amount, userTVL.token1.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.token1.usdValue)}`,
+        subValueColor: "default",
+      },
+    ];
+    cards.push(await this.createApyCard(input));
+    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.`
+  ];
+
+  return {
+    title: `${secondary} YOLO (${input.expiryDate})`,
+    description,
+    vaultTypeDescription,
+    faqs,
+    investmentSteps,
+  };
+};
+
+const usdc = Global.getDefaultTokens().find((t) => t.symbol === "USDC")!;
+const wbtc = Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!;
+
+const btcYoloConfig: YoloVaultStrategyConfig = {
+  id: `btc-yolo-31-dec-2026`,
+  address: ContractAddr.from("0x018ccdff25a642e211f86ace35ba282ebdf342330319ead98cae37258bc9cce1"),
+  startDate: "03-MAR-2026",
+  mainToken: usdc,
+  secondaryToken: wbtc,
+  expiryDate: "31-DEC-2026",
+  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 yoloCopy = getYoloVaultCopy(btcYoloConfig);
+
+// Risk factors intentionally left unrated for this strategy for now.
+// const yoloRiskFactors: RiskFactor[] = [ ... ];
+const yoloRiskFactors: RiskFactor[] = [];
+
+export const YoloVaultStrategies: IStrategyMetadata<YoloVaultSettings>[] = [
+  {
+    id: btcYoloConfig.id,
+    name: yoloCopy.title,
+    description: yoloCopy.description,
+    address: btcYoloConfig.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: [
+      btcYoloConfig.mainToken,
+      btcYoloConfig.secondaryToken,
+    ],
+    protocols: [],
+    risk: {
+      riskFactor: yoloRiskFactors,
+      netRisk: 0,
+      notARisks: getNoRiskTags(yoloRiskFactors),
+    },
+    additionalInfo: {
+      mainToken: btcYoloConfig.mainToken,
+      secondaryToken: btcYoloConfig.secondaryToken,
+      startDate: btcYoloConfig.startDate,
+      expiryDate: btcYoloConfig.expiryDate,
+      totalEpochs: btcYoloConfig.totalEpochs,
+      minEpochDurationSeconds: btcYoloConfig.minEpochDurationSeconds,
+      spendingLevels: btcYoloConfig.spendingLevels,
+      feeBps: btcYoloConfig.feeBps, // swap fee bps
+    },
+    faqs: yoloCopy.faqs,
+    contractDetails: [],
+    investmentSteps: yoloCopy.investmentSteps,
+    settings: {
+      liveStatus: StrategyLiveStatus.HOT,
+      isAudited: false,
+      quoteToken: btcYoloConfig.mainToken,
+      isTransactionHistDisabled: true,
+      maxTVL: new Web3Number("200000", 6),
+    },
+    apyHistoryUIConfig: {
+      showApyHistory: false,
+      noApyHistoryMessage:
+        "APY history is hidden because this is a TVA accumulation vault, not a yield-bearing APY strategy.",
+    },
+  },
+];