@strkfarm/sdk 1.1.8 → 1.1.9

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -0,0 +1,457 @@
+import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType } from "@/interfaces";
+import { AUMTypes, getContractDetails, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalManageCall, UniversalStrategy, UniversalStrategySettings } from "./universal-strategy";
+import { PricerBase } from "@/modules/pricerBase";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { Global } from "@/global";
+import { ApproveCallParams, CommonAdapter, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
+import { AVNU_MIDDLEWARE } from "./universal-adapters/adapter-utils";
+import { LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
+import { EkuboQuoter, ERC20 } from "@/modules";
+import { assert, logger } from "@/utils";
+import { SingleTokenInfo } from "./base-strategy";
+import { Call, Contract, uint256 } from "starknet";
+import ERC4626Abi from "@/data/erc4626.abi.json";
+
+
+export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalStrategySettings> {
+  
+  private quoteAmountToFetchPrice = new Web3Number(1, 18);
+  
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>) {
+    super(config, pricer, metadata);
+
+    const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
+    const underlyingToken = this.getLSTUnderlyingTokenInfo();
+    if (underlyingToken.address.eq(STRKToken.address)) {
+      this.quoteAmountToFetchPrice = new Web3Number(100, 18);
+    } else {
+      // else this BTC
+      this.quoteAmountToFetchPrice = new Web3Number(0.01, this.asset().decimals);
+    }
+  }
+
+  // only one leg is used
+  // todo support lending assets of underlying as well
+  getVesuAdapters() {
+    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    vesuAdapter1.pricer = this.pricer;
+    vesuAdapter1.networkConfig = this.config;
+    
+    return [vesuAdapter1];
+  }
+
+  // not applicable for this strategy
+  // No rewards on collateral or borrowing of LST assets
+  protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
+    return Web3Number.fromWei("0", this.asset().decimals);
+  }
+
+  async getLSTDexPrice() {
+    const ekuboQuoter = new EkuboQuoter(this.config);
+    const lstTokenInfo = this.asset();
+    const lstUnderlyingTokenInfo = this.getLSTUnderlyingTokenInfo();
+    const quote = await ekuboQuoter.getQuote(
+      lstTokenInfo.address.address,
+      lstUnderlyingTokenInfo.address.address,
+      this.quoteAmountToFetchPrice
+    );
+
+    // in Underlying
+    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
+    const price = outputAmount.toNumber() / this.quoteAmountToFetchPrice.toNumber();
+    logger.verbose(`${this.getTag()}:: LST Dex Price: ${price}`);
+    return price;
+  }
+
+  /**
+   * Uses vesu's multiple call to create leverage on LST
+   * Deposit amount is in LST
+   * @param params 
+   */
+  async getVesuMultiplyCall(params: {
+    isDeposit: boolean,
+    leg1DepositAmount: Web3Number
+  }) {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+
+    const existingPositions = await vesuAdapter1.getPositions(this.config);
+    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
+    const existingCollateralInfo = existingPositions[0];
+    const existingDebtInfo = existingPositions[1];
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+    // Price 1 is ok as fallback bcz that would relatively price the 
+    // collateral and debt as equal.
+    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+
+    // compute optimal amount of collateral and debt post addition/removal
+    // target hf = collateral * collateralPrice * ltv / debt * debtPrice
+    // assuming X to be the usd amount of debt borrowed or repaied (negative). 
+    // target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv / (debt * debtPrice + X)
+    // => X * target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv - (debt * debtPrice * target hf)
+    // => X * (target hf - ltv)= ((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)
+    // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
+    const addedCollateral = params.leg1DepositAmount
+      .multipliedBy(params.isDeposit ? 1 : -1)
+    const DEXPrice = await this.getLSTDexPrice();
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
+    const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
+    const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
+    const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / DEXPrice);
+    const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
+
+    // both in underlying
+    const debtAmount = x_debt_usd.dividedBy(debtPrice);
+    const marginAmount = addedCollateral;
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+
+    // Cases of lever increase (within the scopr of this function)
+    // 1. debtAmount > 0 and marginAmount > 0
+    // 2. debtAmount > 0 and marginAmount < 0
+
+    // Cases of lever decrease
+    // 3. debtAmount < 0 and marginAmount > 0
+    // 4. debtAmount < 0 and marginAmount < 0
+    return this.getModifyLeverCall({
+      marginAmount,
+      debtAmount,
+      isIncrease: debtAmount.greaterThan(0)
+    });
+  }
+
+  getLSTUnderlyingTokenInfo() {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    return vesuAdapter1.config.debt;
+  }
+
+  async getLSTExchangeRate() {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const lstTokenInfo = vesuAdapter1.config.collateral;
+    const lstABI = new Contract({
+      abi: ERC4626Abi,
+      address: lstTokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+
+    const price: any = await lstABI.call('convert_to_assets', [uint256.bnToUint256((new Web3Number(1, lstTokenInfo.decimals)).toWei())]);
+    const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
+    logger.verbose(`${this.getTag()}:: LST Exchange Rate: ${exchangeRate}`);
+    return exchangeRate;
+   }
+
+  /**
+   * 
+   * @param params marginAmount is in LST, debtAmount is in underlying
+   */
+  async getModifyLeverCall(params: {
+    marginAmount: Web3Number, // >0 during deposit
+    debtAmount: Web3Number,
+    isIncrease: boolean
+  }): Promise<Call[]> {
+    assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
+    
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const lstTokenInfo = this.asset();
+    const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
+
+    const proofsIDs: string[] = [];
+    const manageCalls: ManageCall[] = [];
+
+    // approve token
+    if (params.marginAmount.greaterThan(0)) {
+      const STEP1_ID = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
+      const manage1Info = this.getProofs<ApproveCallParams>(STEP1_ID);
+      const depositAmount = params.marginAmount;
+      const manageCall1 = manage1Info.callConstructor({
+          amount: depositAmount
+      })
+      proofsIDs.push(STEP1_ID);
+      manageCalls.push(manageCall1);
+    }
+
+    const ekuboQuoter = new EkuboQuoter(this.config);
+
+    // compute quotes for margin swap
+    const lstPrice = await this.getLSTExchangeRate();
+    const marginSwap: Swap[] = [];
+
+
+    // compute quotes for lever swap
+    const MAX_SLIPPAGE = 0.01;
+    // when increasing, debt is swapped to collateral (LST)
+    // when decreasing, collateral is swapped to debt (underlying)
+    // but both cases, we denominate amount in underlying. negative for decrease (exact amount out)
+    const fromToken = params.isIncrease ? lstUnderlyingTokenInfo : lstTokenInfo;
+    const toToken = params.isIncrease ? lstTokenInfo : lstUnderlyingTokenInfo;
+    const leverSwapQuote = await ekuboQuoter.getQuote(
+      fromToken.address.address, 
+      toToken.address.address, 
+      params.debtAmount // negative for exact amount out
+    );
+    assert(leverSwapQuote.price_impact < MAX_SLIPPAGE, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
+    const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
+    const minExpectedDebt = params.debtAmount.dividedBy(lstPrice).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
+    const maxUsedCollateral = params.debtAmount.abs().dividedBy(lstPrice).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
+   
+    const STEP2_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON;
+    const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
+    const manageCall2 = manage2Info.callConstructor({
+      delegation: true
+    });
+
+    // deposit and borrow or repay and withdraw
+    const STEP3_ID = LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU;
+    const manage3Info = this.getProofs<VesuMultiplyCallParams>(STEP3_ID);
+    const multiplyParams: VesuMultiplyCallParams = params.isIncrease ? {
+      isIncrease: true,
+      increaseParams: {
+        add_margin: params.marginAmount,
+        margin_swap: marginSwap,
+        margin_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: minExpectedDebt
+      }
+    } : {
+      isIncrease: false,
+      decreaseParams: {
+        sub_margin: params.marginAmount.multipliedBy(-1),
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: maxUsedCollateral,
+        // only required for close position
+        lever_swap_weights: [],
+        // no need to swap collateral to anything, and any residuals return our contract anyways. 
+        withdraw_swap: [],
+        withdraw_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
+        withdraw_swap_weights: [],
+        close_position: false
+      }
+    }
+    const manageCall3 = manage3Info.callConstructor(multiplyParams);
+
+    // switch delegation off
+    const STEP4_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF;
+    const manage4Info = this.getProofs<VesuModifyDelegationCallParams>(STEP4_ID);
+    const manageCall4 = manage4Info.callConstructor({
+      delegation: false
+    });
+
+    proofsIDs.push(STEP2_ID, STEP3_ID, STEP4_ID);
+    manageCalls.push(manageCall2, manageCall3, manageCall4);
+
+    return [this.getManageCall(proofsIDs, manageCalls)];
+  }
+}
+
+export default function VaultDescription() {
+  const containerStyle = {
+    maxWidth: "800px",
+    margin: "0 auto",
+    backgroundColor: "#111",
+    color: "#eee",
+    fontFamily: "Arial, sans-serif",
+    borderRadius: "12px",
+  };
+
+  return (
+    <div style={containerStyle}>
+      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>Meta Vault — Automated Yield Router</h1>
+      <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
+        This Levered Endur LST vault is a tokenized leveraged Vault, auto-compounding strategy that continuously allocates your deposited
+        asset to the best available yield source in the ecosystem. Depositors receive vault shares that
+        represent a proportional claim on the underlying assets and accrued yield. Allocation shifts are
+        handled programmatically based on on-chain signals and risk filters, minimizing idle capital and
+        maximizing net APY.
+      </p>
+
+      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+        <p style={{ fontSize: "13px", color: "#ccc" }}>
+          <strong>Withdrawals:</strong> Requests can take up to <strong>1-2 hours</strong> to process as the vault unwinds and settles routing.
+        </p>
+      </div>
+    </div>
+  );
+}
+
+
+function getDescription(tokenSymbol: string) {
+  return VaultDescription();
+}
+
+enum LST_MULTIPLIER_MANAGE_IDS  {
+  MULTIPLY_VESU = 'multiply_vesu',
+  SWITCH_DELEGATION_ON = 'switch_delegation_on',
+  SWITCH_DELEGATION_OFF = 'switch_delegation_off'
+}
+
+function getLooperSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  vaultSettings: UniversalStrategySettings,
+  pool1: ContractAddr,
+) {
+  vaultSettings.leafAdapters = [];
+
+  const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
+  const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
+
+  const vesuAdapterLST = new VesuAdapter({
+    poolId: pool1,
+    collateral: lstToken,
+    debt: underlyingToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU
+  })
+
+  const commonAdapter = new CommonAdapter({
+    manager: vaultSettings.manager,
+    asset: lstToken.address,
+    id: '',
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator,
+  })
+
+  // vesu looping
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vesuAdapterLST.VESU_MULTIPLY, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter.bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON).bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF).bind(vesuAdapterLST));
+
+  // Useful for returning adapter class objects that can compute
+  // certain things for us (e.g. positions, hfs)
+  vaultSettings.adapters.push(...[{
+    id: UNIVERSAL_ADAPTERS.VESU_LEG1,
+    adapter: vesuAdapterLST
+  },{
+    id: UNIVERSAL_ADAPTERS.COMMON,
+    adapter: commonAdapter
+  }])
+
+  // to bridge liquidity back to vault (used by bring_liquidity)
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vaultSettings.vaultAddress, UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY).bind(commonAdapter));
+  
+  // claim rewards
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS).bind(vesuAdapterLST));
+
+  // avnu swap for claims rewards
+  const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS).bind(commonAdapter));
+  return vaultSettings;
+}
+
+function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
+  return [
+    {
+      question: `What is the Hyper ${lstSymbol} Vault?`,
+      answer:
+        `The Hyper ${lstSymbol} Vault is a tokenized strategy that automatically loops your ${underlyingSymbol} or ${lstSymbol} to create up to 4x leverage to hence yield in a very low risk manner.`,
+    },
+    {
+      question: "How does yield allocation work?",
+      answer:
+        `The strategy uses deposited ${lstSymbol} to collateralize it on Vesu, borrow more ${underlyingSymbol} to loop further. Instead of manually doing this, using flash loan, this leverage is created in a single gas efficient step. Our continuous monitoring systems gauge current yield and available liquidity in real time to make sure yield is optimal. For instance, if the looping becomes in-efficient in future, the strategy will rebalance to reduce leverage or simply hold ${lstSymbol} to continue earning yield.`,
+    },
+    {
+      question: "Which protocols/dApp are used??",
+      answer: (
+        <span>
+          Currently, the LST is from <strong>Endur</strong> while <strong>Vesu</strong> is used to collateralize the looped position.
+        </span>
+      ),
+    },
+    {
+      question: "Can I get liquidated?",
+      answer: "The strategy uses highly correlated assets which drastically reduces the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.",
+    },
+    {
+      question: "What do I receive when I deposit?",
+      answer:
+        "Depositors receive vault tokens representing their proportional share of the vault. These tokens entitle holders to both the principal and accrued yield.",
+    },
+    {
+      question: "How long do withdrawals take?",
+      answer:
+        "Withdrawals may take up to 1-2 hours to process, as the vault unwinds and settles liquidity routing across integrated protocols. In case of large withdrawals, to avoid slippage, we may slowly unwind the position, which could make the withdrawals longer.",
+    },
+    {
+      question: "Is the Hyper xSTRK Vault non-custodial?",
+      answer:
+        "Yes. The Hyper xSTRK Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent.",
+    },
+    {
+      question: "Is the Vault audited?",
+      answer:
+        "Yes. The Hyper xSTRK Vault is audited by Zellic. Look for safety icon beside the strategy name for more details.",
+    },
+    {
+      question: "Are there any fees?",
+      answer:
+        "Troves charges a performance of 10% on the yield generated. The APY shown is net of this fee. This fee is only applied to the profits earned, ensuring that users retain their initial capital.",
+    },
+  ];
+}
+
+const _riskFactor: RiskFactor[] = [
+  { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 25, reason: "Audited by Zellic" },
+  { type: RiskType.LIQUIDATION_RISK, value: LiquidationRiskLevel.VERY_LOW_PROBABILITY, weight: 50, reason: "The collateral and debt are highly correlated" },
+  { type: RiskType.TECHNICAL_RISK, value: TechnicalRiskLevel.STABLE_INFRASTRUCTURE, weight: 50, reason: "Liquidation can only happen if vault is left un-monitored for weeks, which is highly unlikely. We actively monitor all services on a daily basis." }
+];
+
+const hyperxSTRK: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960'),
+  manager: ContractAddr.from('0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a'),
+  vaultAllocator: ContractAddr.from('0x511d07953a09bc7c505970891507c5a2486d2ea22752601a14db092186d7caa'),
+  redeemRequestNFT: ContractAddr.from('0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095'),
+  aumOracle: ContractAddr.from('0x48cf709870a1a0d453d37de108e0c41b8b89819ef54f95abc0e2e1f98bbe937'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+}
+
+function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
+  return [
+    `Deposit ${underlyingSymbol} into the vault`,
+    `The vault manager loops the ${underlyingSymbol} to buy ${lstSymbol}`,
+    `The vault manager collateralizes the ${lstSymbol} on Vesu`,
+    `The vault manager borrows more ${underlyingSymbol} to loop further`,
+    `Claim BTCFi STRK rewards weekly to swap to ${lstSymbol} and reinvest`,
+    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
+  ]
+}
+
+function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: UniversalStrategySettings): IStrategyMetadata<UniversalStrategySettings> {
+  return {
+    name: `Hyper ${lstSymbol}`,
+    description: getDescription(lstSymbol),
+    address: addresses.vaultAddress,
+    launchBlock: 0,
+    type: 'Other',
+    depositTokens: [Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!],
+    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7xSTRK),
+    risk: {
+      riskFactor: _riskFactor,
+      netRisk:
+        _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+        _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor)
+    },
+    protocols: [Protocols.ENDUR, Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 18),
+    contractDetails: getContractDetails(addresses),
+    faqs: getFAQs(lstSymbol, underlyingSymbol),
+    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+  }
+}
+
+export const HyperLSTStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
+  [
+    getStrategySettings('xSTRK', 'STRK', hyperxSTRK),
+  ]