@strkfarm/sdk 1.0.58 → 1.0.60

package/src/strategies/{universal-strategy.ts → universal-strategy.tsx}

@@ -1,7 +1,7 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
 import { PricerBase } from "@/modules/pricerBase";
-import { getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
+import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
 import { Call, CallData, Contract, num, uint256 } from "starknet";
 import { VesuRebalanceSettings } from "./vesu-rebalance";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
@@ -12,6 +12,7 @@ import { Global } from "@/global";
 import { ERC20 } from "@/modules";
 
 export interface UniversalStrategySettings {
+  vaultAddress: ContractAddr,
   manager: ContractAddr,
   vaultAllocator: ContractAddr,
   redeemRequestNFT: ContractAddr,
@@ -22,6 +23,10 @@ export interface UniversalStrategySettings {
   minHealthFactor: number
 }
 
+export enum AUMTypes {
+  FINALISED = 'finalised',
+  DEFISPRING = 'defispring'
+}
 
 export class UniversalStrategy<
   S extends UniversalStrategySettings
@@ -141,6 +146,20 @@ export class UniversalStrategy<
     return [call1, call2];
   }
 
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = await this.contract.call('convert_to_shares', [uint256.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint256.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
+
   /**
    * Calculates the Total Value Locked (TVL) for a specific user.
    * @param user - Address of the user
@@ -192,14 +211,22 @@ export class UniversalStrategy<
     const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
 
     const positions = await this.getVaultPositions();
+    logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    if (positions.every(p => p.amount.isZero())) {
+      return { net: 0, splits: [{
+        apy: 0, id: 'base'
+      }, {
+        apy: 0, id: 'defispring'
+      }]};
+    }
     const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
     const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
     assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
     const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
     const baseAPY = this.computeAPY(baseAPYs, weights);
     const rewardAPY = this.computeAPY(rewardAPYs, weights);
-    const apys = [...baseAPYs, ...rewardAPYs];
     const netAPY = baseAPY + rewardAPY;
+    logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
     return { net: netAPY, splits: [{
       apy: baseAPY, id: 'base'
     }, {
@@ -235,6 +262,17 @@ export class UniversalStrategy<
     };
   }
 
+  async getUnusedBalance(): Promise<SingleTokenInfo> {
+    const balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
+
   async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
     const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
     const lastReportTime = await this.contract.call('last_report_timestamp', []);
@@ -246,13 +284,30 @@ export class UniversalStrategy<
     const leg1AUM = await vesuAdapter1.getPositions(this.config);
     const leg2AUM = await vesuAdapter2.getPositions(this.config);
 
-    const balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
-    logger.verbose(`${this.getTag()} unused balance: ${balance}`);
+    const balance = await this.getUnusedBalance();
+    logger.verbose(`${this.getTag()} unused balance: ${balance.amount.toNumber()}`);
 
-    const aumToken = leg1AUM[0].amount
+    const vesuAum = leg1AUM[0].amount
       .plus(leg2AUM[0].usdValue / token1Price.price)
       .minus(leg1AUM[1].usdValue / token1Price.price)
-      .minus(leg2AUM[1].amount).plus(balance);
+      .minus(leg2AUM[1].amount);
+    logger.verbose(`${this.getTag()} Vesu AUM: leg1: ${leg1AUM[0].amount.toNumber()}, ${leg1AUM[1].amount.toNumber()}, leg2: ${leg2AUM[0].amount.toNumber()}, ${leg2AUM[1].amount.toNumber()}`);
+
+    const zeroAmt = Web3Number.fromWei('0', this.asset().decimals);
+    const net = {
+      tokenInfo: this.asset(),
+      amount: zeroAmt,
+      usdValue: 0
+    };
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    if (vesuAum.isZero()) {
+      return { net, splits: [{
+        aum: zeroAmt, id: AUMTypes.FINALISED
+      }, {
+        aum: zeroAmt, id: AUMTypes.DEFISPRING
+      }], prevAum};
+    }
+    const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
 
     // calculate estimated growth from strk rewards
@@ -262,7 +317,6 @@ export class UniversalStrategy<
 
     const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
     const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
-    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
     const rewardAssets = prevAum.multipliedBy(growthRate);
     logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
     logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
@@ -272,16 +326,13 @@ export class UniversalStrategy<
     const newAUM = aumToken.plus(rewardAssets);
     logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
     
-    const net = {
-      tokenInfo: this.asset(),
-      amount: newAUM,
-      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
-    };
+    net.amount = newAUM;
+    net.usdValue = newAUM.multipliedBy(token1Price.price).toNumber();
     const splits = [{
-      id: 'finalised',
+      id: AUMTypes.FINALISED,
       aum: aumToken
     }, {
-      id: 'defispring',
+      id: AUMTypes.DEFISPRING,
       aum: rewardAssets
     }];
     return { net, splits, prevAum };
@@ -500,20 +551,25 @@ export class UniversalStrategy<
     logger.verbose(`${this.getTag()}:: borrow1Amount: ${borrow1Amount.toString()} ${vesuAdapter1.config.debt.symbol}`);
     logger.verbose(`${this.getTag()}:: borrow2Amount: ${borrow2Amount.toString()} ${vesuAdapter2.config.debt.symbol}`);
 
-    const callSet1 = this.getVesuModifyPositionCalls({
+    let callSet1 = this.getVesuModifyPositionCalls({
       isLeg1: true,
       isDeposit: params.isDeposit,
       depositAmount: params.leg1DepositAmount.plus(borrow2Amount),
       debtAmount: borrow1Amount
     });
 
-    const callSet2 = this.getVesuModifyPositionCalls({
+    let callSet2 = this.getVesuModifyPositionCalls({
       isLeg1: false,
       isDeposit: params.isDeposit,
       depositAmount: borrow1Amount,
       debtAmount: borrow2Amount
     });
 
+    if (!params.isDeposit) {
+      let temp = callSet2;
+      callSet2 = [...callSet1];
+      callSet1 = [...temp];
+    }
     const allActions = [...callSet1.map(i => i.manageCall), ...callSet2.map(i => i.manageCall)];
     const flashloanCalldata = CallData.compile([
         [...callSet1.map(i => i.proofs), ...callSet2.map(i => i.proofs)],
@@ -534,6 +590,21 @@ export class UniversalStrategy<
     return manageCall;
   }
 
+  async getBringLiquidityCall(params: {
+    amount: Web3Number
+  }) {
+    const manage1Info = this.getProofs<ApproveCallParams>(UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY);
+    const manageCall1 = manage1Info.callConstructor({
+        amount: params.amount
+    });
+    const manage2Info = this.getProofs<ApproveCallParams>(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY);
+    const manageCall2 = manage2Info.callConstructor({
+        amount: params.amount
+    });
+    const manageCall = this.getManageCall([UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY, UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY], [manageCall1, manageCall2]);
+    return manageCall;
+  }
+
   async getRebalanceCall(params: {
     isLeg1toLeg2: boolean,
     amount: Web3Number
@@ -567,12 +638,15 @@ export class UniversalStrategy<
 }
 
 
+// useful to map readble names to proofs and calls
 export enum UNIVERSAL_MANAGE_IDS {
   FLASH_LOAN = 'flash_loan_init',
   VESU_LEG1 = 'vesu_leg1',
   VESU_LEG2 = 'vesu_leg2',
   APPROVE_TOKEN1 = 'approve_token1',
-  APPROVE_TOKEN2 = 'approve_token2'
+  APPROVE_TOKEN2 = 'approve_token2',
+  APPROVE_BRING_LIQUIDITY = 'approve_bring_liquidity',
+  BRING_LIQUIDITY = 'bring_liquidity'
 }
 
 export enum UNIVERSAL_ADAPTERS {
@@ -586,7 +660,7 @@ function getLooperSettings(
   token2Symbol: string,
   vaultSettings: UniversalStrategySettings,
   pool1: ContractAddr,
-  pool2: ContractAddr
+  pool2: ContractAddr,
 ) {
   const USDCToken = Global.getDefaultTokens().find(token => token.symbol === token1Symbol)!;
   const ETHToken = Global.getDefaultTokens().find(token => token.symbol === token2Symbol)!;
@@ -594,7 +668,9 @@ function getLooperSettings(
   const commonAdapter = new CommonAdapter({
     manager: vaultSettings.manager,
     asset: USDCToken.address,
-    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator,
   })
   const vesuAdapterUSDCETH = new VesuAdapter({
     poolId: pool1,
@@ -620,20 +696,28 @@ function getLooperSettings(
     id: UNIVERSAL_ADAPTERS.VESU_LEG2,
     adapter: vesuAdapterETHUSDC
   }])
+
+  // vesu looping
   vaultSettings.leafAdapters.push(commonAdapter.getFlashloanAdapter.bind(commonAdapter));
   vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getModifyPosition.bind(vesuAdapterUSDCETH));
   vaultSettings.leafAdapters.push(vesuAdapterETHUSDC.getModifyPosition.bind(vesuAdapterETHUSDC));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vesuAdapterUSDCETH.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2).bind(commonAdapter));
+  
+  // to bridge liquidity back to vault (used by bring_liquidity)
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.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 _riskFactor: RiskFactor[] = [
   { type: RiskType.SMART_CONTRACT_RISK, value: 0.5, weight: 25, reason: "Audited by Zellic" },
-  { type: RiskType.LIQUIDATION_RISK, value: 1, weight: 50, reason: "Liquidation risk is mitigated btable price feed on Starknet" }
+  { type: RiskType.LIQUIDATION_RISK, value: 1.5, weight: 50, reason: "Liquidation risk is mitigated by stable price feed on Starknet" },
+  { type: RiskType.TECHNICAL_RISK, value: 1, weight: 50, reason: "Technical failures like risk monitoring failures" }
 ];
 
 const usdcVaultSettings: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e'),
   manager: ContractAddr.from('0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07'),
   vaultAllocator: ContractAddr.from('0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba'),
   redeemRequestNFT: ContractAddr.from('0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda'),
@@ -645,6 +729,7 @@ const usdcVaultSettings: UniversalStrategySettings = {
 }
 
 const wbtcVaultSettings: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c'),
   manager: ContractAddr.from('0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34'),
   vaultAllocator: ContractAddr.from('0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735'),
   redeemRequestNFT: ContractAddr.from('0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2'),
@@ -655,11 +740,206 @@ const wbtcVaultSettings: UniversalStrategySettings = {
   minHealthFactor: 1.25
 }
 
+const ethVaultSettings: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8'),
+  manager: ContractAddr.from('0x494888b37206616bd09d759dcda61e5118470b9aa7f58fb84f21c778a7b8f97'),
+  vaultAllocator: ContractAddr.from('0x4acc0ad6bea58cb578d60ff7c31f06f44369a7a9a7bbfffe4701f143e427bd'),
+  redeemRequestNFT: ContractAddr.from('0x2e6cd71e5060a254d4db00655e420db7bf89da7755bb0d5f922e2f00c76ac49'),
+  aumOracle: ContractAddr.from("0x4b747f2e75c057bed9aa2ce46fbdc2159dc684c15bd32d4f95983a6ecf39a05"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const strkVaultSettings: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21'),
+  manager: ContractAddr.from('0xcc6a5153ca56293405506eb20826a379d982cd738008ef7e808454d318fb81'),
+  vaultAllocator: ContractAddr.from('0xf29d2f82e896c0ed74c9eff220af34ac148e8b99846d1ace9fbb02c9191d01'),
+  redeemRequestNFT: ContractAddr.from('0x46902423bd632c428376b84fcee9cac5dbe016214e93a8103bcbde6e1de656b'),
+  aumOracle: ContractAddr.from("0x6d7dbfad4bb51715da211468389a623da00c0625f8f6efbea822ee5ac5231f4"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const usdtVaultSettings: UniversalStrategySettings = {
+  vaultAddress: ContractAddr.from('0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3'),
+  manager: ContractAddr.from('0x39bb9843503799b552b7ed84b31c06e4ff10c0537edcddfbf01fe944b864029'),
+  vaultAllocator: ContractAddr.from('0x56437d18c43727ac971f6c7086031cad7d9d6ccb340f4f3785a74cc791c931a'),
+  redeemRequestNFT: ContractAddr.from('0x5af0c2a657eaa8e23ed78e855dac0c51e4f69e2cf91a18c472041a1f75bb41f'),
+  aumOracle: ContractAddr.from("0x7018f8040c8066a4ab929e6760ae52dd43b6a3a289172f514750a61fcc565cc"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+export default function MetaVaultDescription() {
+  const logos: any = {
+    vesu: Protocols.VESU.logo,
+    endur: Protocols.ENDUR.logo,
+    extended: Protocols.EXTENDED.logo,
+    ekubo: "https://dummyimage.com/64x64/ffffff/000000&text=K",
+  };
+  const sources = [
+    { key: "vesu", name: "Vesu", status: "Live", description: "Integrated liquidity venue used for automated routing to capture the best available yield." },
+    { key: "endur", name: "Endur", status: "Coming soon", description: "Planned integration to tap into STRK staking–backed yields via our LST pipeline." },
+    { key: "extended", name: "Extended", status: "Coming soon", description: "Expanding coverage to additional money markets and vaults across the ecosystem." },
+    // { key: "ekubo", name: "Ekubo", status: "Coming soon", description: "Concentrated liquidity strategies targeted for optimized fee APR harvesting." },
+  ];
+
+  const containerStyle = {
+    maxWidth: "800px",
+    margin: "0 auto",
+    backgroundColor: "#111",
+    color: "#eee",
+    fontFamily: "Arial, sans-serif",
+    borderRadius: "12px",
+  };
+
+  const cardStyle = {
+    border: "1px solid #333",
+    borderRadius: "10px",
+    padding: "12px",
+    marginBottom: "12px",
+    backgroundColor: "#1a1a1a",
+  };
+
+  const logoStyle = {
+    width: "24px",
+    height: "24px",
+    borderRadius: "8px",
+    border: "1px solid #444",
+    backgroundColor: "#222",
+  };
+
+  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 Evergreen vault is a tokenized Meta 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>
+
+      <h2 style={{ fontSize: "18px", marginBottom: "10px" }}>Supported Yield Sources</h2>
+      {sources.map((s) => (
+        <div key={s.key} style={cardStyle}>
+          <div style={{ display: "flex", gap: "10px", alignItems: "flex-start" }}>
+            <img src={logos[s.key]} alt={`${s.name} logo`} style={logoStyle} />
+            <div style={{ flex: 1 }}>
+              <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+                <h3 style={{ fontSize: "15px", margin: 0 }}>{s.name}</h3>
+                <StatusBadge status={s.status} />
+              </div>
+              {/* <p style={{ fontSize: "13px", color: "#ccc", marginTop: "4px" }}>{s.description}</p> */}
+            </div>
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function StatusBadge({ status }: { status: string }) {
+  const isSoon = String(status).toLowerCase() !== "live";
+  const badgeStyle = {
+    fontSize: "12px",
+    padding: "2px 6px",
+    borderRadius: "12px",
+    border: "1px solid",
+    color: isSoon ? "rgb(196 196 195)" : "#6aff7d",
+    borderColor: isSoon ? "#484848" : "#6aff7d",
+    backgroundColor: isSoon ? "#424242" : "#002b1a",
+  };
+  return <span style={badgeStyle}>{status}</span>;
+}
+
+function getDescription(tokenSymbol: string) {
+  return MetaVaultDescription();
+}
+
+function getFAQs(): FAQ[] {
+  return [
+    {
+      question: "What is the Meta Vault?",
+      answer:
+        "The Meta Vault is a tokenized strategy that automatically allocates your deposited assets to the best available yield source in the ecosystem. It optimizes returns while minimizing idle capital.",
+    },
+    {
+      question: "How does yield allocation work?",
+      answer:
+        "The vault continuously monitors supported protocols and routes liquidity to the source offering the highest net yield after accounting for fees, slippage, and gas costs. Reallocations are performed automatically.",
+    },
+    {
+      question: "Which yield sources are supported?",
+      answer: (
+        <span>
+          Currently, <strong>Vesu</strong> is live. Future integrations include{" "}
+          <strong>Endur</strong>, <strong>Extended</strong>, and{" "}
+          <strong>Ekubo</strong> (all coming soon).
+        </span>
+      ),
+    },
+    {
+      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.",
+    },
+    {
+      question: "Is the Meta Vault non-custodial?",
+      answer:
+        "Yes. The Meta Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent.",
+    },
+    {
+      question: "How is risk managed?",
+      answer:
+        "Integrations are supported with active risk monitoring like liquidation risk. Only vetted protocols are included to balance yield with safety. However, usual Defi risks like smart contract risk, extreme volatile market risk, etc. are still present.",
+    },
+    {
+      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.",
+    },
+  ];
+}
+
+function getContractDetails(settings: UniversalStrategySettings): {address: ContractAddr, name: string}[] {
+  return [
+    { address: settings.vaultAddress, name: "Vault" },
+    { address: settings.manager, name: "Vault Manager" },
+    { address: settings.vaultAllocator, name: "Vault Allocator" },
+    { address: settings.redeemRequestNFT, name: "Redeem Request NFT" },
+    { address: settings.aumOracle, name: "AUM Oracle" },
+  ];
+}
+
+const investmentSteps: string[] = [
+  "Deposit funds into the vault",
+  "Vault manager allocates funds to optimal yield sources",
+  "Vault manager reports asset under management (AUM) regularly to the vault",
+  "Request withdrawal and vault manager processes it in 1-2 hours"
+]
 export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
   [
     {
       name: "USDC Evergreen",
-      description: "A universal strategy for managing USDC assets",
+      description: getDescription('USDC'),
       address: ContractAddr.from('0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e'),
       launchBlock: 0,
       type: 'ERC4626',
@@ -674,13 +954,13 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 6),
-      contractDetails: [],
-      faqs: [],
-      investmentSteps: [],
+      contractDetails: getContractDetails(usdcVaultSettings),
+      faqs: getFAQs(),
+      investmentSteps: investmentSteps,
     },
     {
       name: "WBTC Evergreen",
-      description: "A universal strategy for managing WBTC assets",
+      description: getDescription('WBTC'),
       address: ContractAddr.from('0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c'),
       launchBlock: 0,
       type: 'ERC4626',
@@ -695,8 +975,71 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 8),
-      contractDetails: [],
-      faqs: [],
-      investmentSteps: [],
+      contractDetails: getContractDetails(wbtcVaultSettings),
+      faqs: getFAQs(),
+      investmentSteps: investmentSteps,
     },
+    {
+      name: "ETH Evergreen",
+      description: getDescription('ETH'),
+      address: ContractAddr.from('0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'ETH')!],
+      additionalInfo: getLooperSettings('ETH', 'WBTC', ethVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      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.VESU],
+      maxTVL: Web3Number.fromWei(0, 18),
+      contractDetails: getContractDetails(ethVaultSettings),
+      faqs: getFAQs(),
+      investmentSteps: investmentSteps,
+    },
+    {
+      name: "STRK Evergreen",
+      description: getDescription('STRK'),
+      address: ContractAddr.from('0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'STRK')!],
+      additionalInfo: getLooperSettings('STRK', 'ETH', strkVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      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.VESU],
+      maxTVL: Web3Number.fromWei(0, 18),
+      contractDetails: getContractDetails(strkVaultSettings),
+      faqs: getFAQs(),
+      investmentSteps: investmentSteps,
+    },
+    {
+      name: "USDT Evergreen",
+      description: getDescription('USDT'),
+      address: ContractAddr.from('0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDT')!],
+      additionalInfo: getLooperSettings('USDT', 'ETH', usdtVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      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.VESU],
+      maxTVL: Web3Number.fromWei(0, 6),
+      contractDetails: getContractDetails(usdtVaultSettings),
+      faqs: getFAQs(),
+      investmentSteps: investmentSteps,
+    }
   ]

package/src/utils/cacheClass.ts

@@ -1,29 +1,29 @@
-interface CacheData {
-  timestamp: number;
-  ttl: number;
-  data: any;
-}
-export class CacheClass {
-    readonly cache: Map<string, CacheData> = new Map();
-
-    setCache(key: string, data: any, ttl: number = 60000): void {
-        const timestamp = Date.now();
-        this.cache.set(key, { timestamp, ttl, data });
-    }
-
-    getCache<T>(key: string): T | null {
-        const cachedData = this.cache.get(key);
-        if (!cachedData || !this.isCacheValid(key)) {
-            return null;
-        }
-        return cachedData.data;
-    }
-
-    isCacheValid(key: string): boolean {
-        const cachedData = this.cache.get(key);
-        if (!cachedData) return false;
-
-        const { timestamp, ttl } = cachedData;
-        return Date.now() - timestamp <= ttl;
-    }
+interface CacheData {
+  timestamp: number;
+  ttl: number;
+  data: any;
+}
+export class CacheClass {
+    readonly cache: Map<string, CacheData> = new Map();
+
+    setCache(key: string, data: any, ttl: number = 60000): void {
+        const timestamp = Date.now();
+        this.cache.set(key, { timestamp, ttl, data });
+    }
+
+    getCache<T>(key: string): T | null {
+        const cachedData = this.cache.get(key);
+        if (!cachedData || !this.isCacheValid(key)) {
+            return null;
+        }
+        return cachedData.data;
+    }
+
+    isCacheValid(key: string): boolean {
+        const cachedData = this.cache.get(key);
+        if (!cachedData) return false;
+
+        const { timestamp, ttl } = cachedData;
+        return Date.now() - timestamp <= ttl;
+    }
 }