@strkfarm/sdk 2.0.0-staging.6 → 2.0.0-staging.60

package/src/strategies/universal-strategy.tsx

@@ -1,7 +1,13 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import {
+  BaseStrategy,
+  SingleActionAmount,
+  SingleTokenInfo,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
 import { PricerBase } from "@/modules/pricerBase";
-import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyCategory, StrategyTag, VaultPosition, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings } from "@/interfaces";
+import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyTag, VaultPosition, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo, UnwrapLabsCurator } from "@/interfaces";
 import { BlockIdentifier, Call, CallData, Contract, num, uint256 } from "starknet";
 import { VesuRebalanceSettings } from "./vesu-rebalance";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
@@ -11,6 +17,7 @@ import { ApproveCallParams, AvnuSwapCallParams, BaseAdapter, CommonAdapter, Flas
 import { Global } from "@/global";
 import { AvnuWrapper, ERC20 } from "@/modules";
 import { AVNU_MIDDLEWARE, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
+import { LSTPriceType } from "./types";
 import { HarvestInfo, VesuHarvests } from "@/modules/harvests";
 
 export interface UniversalManageCall {
@@ -212,7 +219,7 @@ export class UniversalStrategy<
     });
     logger.verbose(`${this.metadata.name}::netAPY: vesu-pools: ${JSON.stringify(pools)}`);
     if (pools.some(p => !p)) {
-      throw new Error('Pool not found');
+      throw new Error(`Pool not found`);
     };
     const positions = await this.getVesuPositions();
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
@@ -403,6 +410,50 @@ export class UniversalStrategy<
     return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
   }
 
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const { user, investmentFlows = [] } = input;
+    const [userTVL] = await Promise.all([
+      this.getUserTVL(user),
+    ]);
+    const cards: UserPositionCard[] = [
+      {
+        title: "Your Holdings",
+        tooltip: "Your Holdings",
+        value: this.formatTokenAmountForCard(userTVL.amount, userTVL.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(userTVL.usdValue)}`,
+        subValueColor: "positive",
+      },
+    ];
+
+    let lifetimeAmount = userTVL.amount.multipliedBy(0);
+    let lifetimeTokenInfo = userTVL.tokenInfo;
+    let lifetimeUsdValue = 0;
+    if (investmentFlows.length > 0) {
+      try {
+        const earningsResult = this.getLifetimeEarnings(userTVL, investmentFlows);
+        lifetimeAmount = earningsResult.lifetimeEarnings;
+        lifetimeTokenInfo = earningsResult.tokenInfo.tokenInfo;
+        const userAmount = userTVL.amount.toNumber();
+        if (Number.isFinite(userAmount) && userAmount > 0) {
+          const pricePerToken = userTVL.usdValue / userAmount;
+          lifetimeUsdValue = lifetimeAmount.toNumber() * pricePerToken;
+        }
+      } catch (error) {
+        logger.warn(`${this.getTag()}::getUserPositionCards lifetime earnings fallback`, error);
+      }
+    }
+
+    cards.push({
+      title: "Lifetime Earnings",
+      tooltip: "Lifetime Earnings",
+      value: this.formatTokenAmountForCard(lifetimeAmount, lifetimeTokenInfo),
+      subValue: `≈ ${this.formatUSDForCard(lifetimeUsdValue)}`,
+      subValueColor: this.getSubValueColorFromSignedNumber(lifetimeUsdValue),
+    });
+
+    return cards;
+  }
+
   /**
      * Calculates the total TVL of the strategy.
      * @returns Object containing the total amount in token units and USD value
@@ -424,6 +475,11 @@ export class UniversalStrategy<
     };
   }
 
+  async getMaxTVL(): Promise<Web3Number> {
+    // This strategy doesn't have a maxTVL so returning 0 simply
+    return new Web3Number('0', 18);
+  }
+
   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);
@@ -435,7 +491,7 @@ export class UniversalStrategy<
     };
   }
 
-  protected async getVesuAUM(adapter: VesuAdapter) {
+  protected async getVesuAUM(adapter: VesuAdapter, _priceType?: LSTPriceType) {
     const legAUM = await adapter.getPositions(this.config);
     const underlying = this.asset();
     let vesuAum = Web3Number.fromWei("0", underlying.decimals);
@@ -468,7 +524,7 @@ export class UniversalStrategy<
     return prevAum;
   }
 
-  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+  async getAUM(unrealizedAUM?: boolean): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
     const prevAum = await this.getPrevAUM();
     const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
 
@@ -476,7 +532,9 @@ export class UniversalStrategy<
     const vesuAdapters = this.getVesuAdapters();
     let vesuAum = Web3Number.fromWei("0", this.asset().decimals);
     for (const adapter of vesuAdapters) {
-      vesuAum = vesuAum.plus(await this.getVesuAUM(adapter));
+      const priceType = unrealizedAUM ? LSTPriceType.ENDUR_PRICE : LSTPriceType.AVNU_PRICE;
+      const aumValue = await this.getVesuAUM(adapter, priceType);
+      vesuAum = vesuAum.plus(aumValue);
     }
 
     // account unused balance as aum as well (from vault allocator)
@@ -1095,7 +1153,6 @@ export default function MetaVaultDescription(allowedSources: AllowedSources[]) {
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -1122,7 +1179,6 @@ export default function MetaVaultDescription(allowedSources: AllowedSources[]) {
       <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.
@@ -1251,27 +1307,28 @@ const getUniversalRisk = () => ({
 
 // Helper to create Universal strategy settings
 const createUniversalSettings = (
-    tokenSymbol: string,
-    maxTVLDecimals: number
-): StrategySettings => ({
-    maxTVL: Web3Number.fromWei(0, maxTVLDecimals),
-    isAudited: true,
-    liveStatus: StrategyLiveStatus.ACTIVE,
-    isPaused: false,
-    isInstantWithdrawal: false,
-    hideHarvestInfo: true,
-    quoteToken: Global.getDefaultTokens().find(
-        (token) => token.symbol === tokenSymbol
-    )!,
-    alerts: [
-        {
-            tab: "withdraw" as const,
-            text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 1-2 hours. You can monitor the status in transactions tab.",
-            type: "info" as const
-        }
-    ],
-    showWithdrawalWarningModal: true
-});
+    tokenSymbol: string
+): StrategySettings => {
+    const isUSDT = tokenSymbol === "USDT";
+    return {
+        isAudited: true,
+        liveStatus: isUSDT ? StrategyLiveStatus.RETIRED : StrategyLiveStatus.ACTIVE,
+        isPaused: isUSDT,
+        isInstantWithdrawal: false,
+        hideHarvestInfo: true,
+        quoteToken: Global.getDefaultTokens().find(
+            (token) => token.symbol === tokenSymbol
+        )!,
+        alerts: [
+            {
+                tab: "withdraw" as const,
+                text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 1-2 hours. You can monitor the status in transactions tab.",
+                type: "info" as const
+            }
+        ],
+        showWithdrawalWarningModal: true
+    };
+};
 
 const EVERGREEN_SECURITY = {
   auditStatus: AuditStatus.AUDITED,
@@ -1281,18 +1338,21 @@ const EVERGREEN_SECURITY = {
   },
   accessControl: {
     type: AccessControlType.STANDARD_ACCOUNT,
-    addresses: [ContractAddr.from("0x0")],
-    timeLock: "2 Days",
+    addresses: [ContractAddr.from("0x03495DD1e4838aa06666aac236036D86E81A6553e222FC02e70C2Cbc0062e8d0")],
   },
 };
 
-const EVERGREEN_REDEMPTION_INFO = {
+const EVERGREEN_REDEMPTION_INFO: RedemptionInfo = {
   instantWithdrawalVault: InstantWithdrawalVault.NO,
-  expectedRedemptionTime: {
-    upto1M: "1-2hrs",
-    upto10M: "24hrs",
-    above10M: "2-3 Days",
-  },
+  redemptionsInfo: [{
+      title: "Typical Duration",
+      description: "1-2 hours"
+  }],
+  alerts: [{
+    type: 'info',
+    text: 'In cases of low liquidity, high slippages, the redemptions can take longer time. Redemption times are estimates and may vary based on network conditions and liquidity requirements.',
+    tab: 'withdraw'
+  }]
 };
 
 // Helper to create a Universal strategy
@@ -1302,38 +1362,50 @@ const createUniversalStrategy = (params: {
     vaultSettings: UniversalStrategySettings;
     token1Symbol: string;
     token2Symbol: string;
-    maxTVLDecimals: number;
     allowedSources: AllowedSources[];
     tags: StrategyTag[];
-}): IStrategyMetadata<UniversalStrategySettings> => ({
-    id: `evergreen_${params.tokenSymbol.toLowerCase()}`,
-    name: `${params.tokenSymbol} Evergreen`,
-    description: getDescription(params.tokenSymbol, params.allowedSources),
-    address: ContractAddr.from(params.address),
-    launchBlock: 0,
-    type: "ERC4626" as const,
-    depositTokens: [
-        Global.getDefaultTokens().find((token) => token.symbol === params.tokenSymbol)!
-    ],
-    additionalInfo: getLooperSettings(
-        params.token1Symbol,
-        params.token2Symbol,
-        params.vaultSettings,
-        VesuPools.Genesis,
-        VesuPools.Genesis
-    ),
-    risk: getUniversalRisk(),
-    auditUrl: AUDIT_URL,
-    protocols: [Protocols.VESU],
-    settings: createUniversalSettings(params.tokenSymbol, params.maxTVLDecimals),
-    contractDetails: getContractDetails(params.vaultSettings),
-    faqs: getFAQs(),
-    investmentSteps: investmentSteps,
-    category: StrategyCategory.META_VAULTS,
-    tags: params.tags,
-    security: EVERGREEN_SECURITY,
-    redemptionInfo: EVERGREEN_REDEMPTION_INFO
-});
+}): IStrategyMetadata<UniversalStrategySettings> => {
+    const isUSDT = params.tokenSymbol === "USDT";
+    return {
+        id: `evergreen_${params.tokenSymbol.toLowerCase()}`,
+        name: `${params.tokenSymbol} Evergreen`,
+        description: getDescription(params.tokenSymbol, params.allowedSources),
+        address: ContractAddr.from(params.address),
+        launchBlock: 0,
+        type: "ERC4626" as const,
+        vaultType: {
+          type: VaultType.META_VAULT,
+          description: "Automatically allocates funds to the best available yield source in the ecosystem"
+        },
+        depositTokens: [
+            Global.getDefaultTokens().find((token) => token.symbol === params.tokenSymbol)!
+        ],
+        additionalInfo: getLooperSettings(
+            params.token1Symbol,
+            params.token2Symbol,
+            params.vaultSettings,
+            VesuPools.Genesis,
+            VesuPools.Genesis
+        ),
+        risk: getUniversalRisk(),
+        auditUrl: AUDIT_URL,
+        protocols: [Protocols.VESU],
+        realizedApyMethodology: "The realizedAPY is based on past 14 days performance by the vault",
+        curator: UnwrapLabsCurator,
+        settings: createUniversalSettings(params.tokenSymbol),
+        contractDetails: getContractDetails(params.vaultSettings),
+        faqs: getFAQs(),
+        investmentSteps: investmentSteps,
+        tags: params.tags,
+        security: EVERGREEN_SECURITY,
+        redemptionInfo: EVERGREEN_REDEMPTION_INFO,
+        discontinuationInfo: isUSDT ? {
+            info: "This strategy has been retired and is no longer accepting new deposits."
+        } : undefined,
+        usualTimeToEarnings: null,
+        usualTimeToEarningsDescription: null,
+    };
+};
 
 export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
 [
@@ -1343,9 +1415,8 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
         vaultSettings: usdcVaultSettings,
         token1Symbol: "USDC.e",
         token2Symbol: "ETH",
-        maxTVLDecimals: 6,
         allowedSources: ["vesu", "extended"],
-        tags: [StrategyTag.EVERGREEN]
+        tags: [StrategyTag.META_VAULT]
     }),
     createUniversalStrategy({
         tokenSymbol: "WBTC",
@@ -1353,9 +1424,8 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
         vaultSettings: wbtcVaultSettings,
         token1Symbol: "WBTC",
         token2Symbol: "ETH",
-        maxTVLDecimals: 8,
         allowedSources: ["vesu", "endur", "extended"],
-        tags: [StrategyTag.BTC, StrategyTag.EVERGREEN]
+        tags: [StrategyTag.BTC, StrategyTag.META_VAULT]
     }),
     createUniversalStrategy({
         tokenSymbol: "ETH",
@@ -1363,9 +1433,8 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
         vaultSettings: ethVaultSettings,
         token1Symbol: "ETH",
         token2Symbol: "WBTC",
-        maxTVLDecimals: 18,
         allowedSources: ["vesu", "extended"],
-        tags: [StrategyTag.EVERGREEN]
+        tags: [StrategyTag.META_VAULT]
     }),
     createUniversalStrategy({
         tokenSymbol: "STRK",
@@ -1373,9 +1442,8 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
         vaultSettings: strkVaultSettings,
         token1Symbol: "STRK",
         token2Symbol: "ETH",
-        maxTVLDecimals: 18,
         allowedSources: ["vesu", "endur", "extended"],
-        tags: [StrategyTag.EVERGREEN]
+        tags: [StrategyTag.META_VAULT]
     }),
     createUniversalStrategy({
         tokenSymbol: "USDT",
@@ -1383,8 +1451,7 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
         vaultSettings: usdtVaultSettings,
         token1Symbol: "USDT",
         token2Symbol: "ETH",
-        maxTVLDecimals: 6,
         allowedSources: ["vesu"],
-        tags: [StrategyTag.EVERGREEN]
+        tags: [StrategyTag.META_VAULT]
     })
 ];

package/src/strategies/vesu-rebalance.tsx

@@ -10,7 +10,6 @@ import {
   IStrategyMetadata,
   RiskFactor,
   RiskType,
-  StrategyCategory,
   StrategyTag,
   AuditStatus,
   SourceCodeType,
@@ -18,6 +17,8 @@ import {
   InstantWithdrawalVault,
   StrategySettings,
   StrategyLiveStatus,
+  VaultType,
+  UnwrapLabsCurator,
 } from "@/interfaces";
 import { AvnuWrapper, Pricer, SwapInfo } from "@/modules";
 import { Account, CairoCustomEnum, Contract, num, uint256, BlockIdentifier } from "starknet";
@@ -35,7 +36,7 @@ import {
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
 import { HarvestInfo, VesuHarvests } from "@/modules/harvests";
 import VesuPoolIDs from "@/data/vesu_pools.json";
-import { COMMON_CONTRACTS, ENDPOINTS } from "./constants";
+import { ENDPOINTS } from "./constants";
 
 interface PoolProps {
   pool_id: ContractAddr;
@@ -334,7 +335,7 @@ export class VesuRebalance extends BaseStrategy<
   }
 
   static async getAllPossibleVerifiedPools(asset: ContractAddr) {
-    const data = await getAPIUsingHeadlessBrowser(`${ENDPOINTS.VESU_BASE_STAGING}/pools`);
+    const data = await getAPIUsingHeadlessBrowser(`${ENDPOINTS.VESU_BASE}/pools`);
     const verifiedPools = data.data.filter((d: any) => d.isVerified);
     const pools = verifiedPools
       .map((p: any) => {
@@ -600,7 +601,7 @@ export class VesuRebalance extends BaseStrategy<
     let pools: any[] = [];
     try {
       const data = await getAPIUsingHeadlessBrowser(
-        `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+        `${ENDPOINTS.VESU_BASE}/pools`
       );
       pools = data.data;
 
@@ -1031,9 +1032,8 @@ const createVesuRebalanceSettings = (tokenSymbol: string): StrategySettings => {
         (t) => t.symbol === tokenSymbol
     )!;
     return {
-        maxTVL: Web3Number.fromWei("0", depositToken.decimals),
         isPaused: false,
-        liveStatus: StrategyLiveStatus.ACTIVE,
+        liveStatus: StrategyLiveStatus.DEPRECATED,
         isAudited: true,
         isInstantWithdrawal: true,
         quoteToken: depositToken,
@@ -1043,21 +1043,27 @@ const createVesuRebalanceSettings = (tokenSymbol: string): StrategySettings => {
 
 // Helper to create a Vesu Rebalance strategy
 const createVesuRebalanceStrategy = (
+    idSymbol: string,
     name: string,
     tokenSymbol: string,
     address: string
 ): IStrategyMetadata<VesuRebalanceSettings> => ({
-    id: `vesu_fusion_${tokenSymbol.toLowerCase()}`,
+    id: `vesu_fusion_${idSymbol.toLowerCase()}`,
     name,
     description: _description.replace("{{TOKEN}}", tokenSymbol),
     address: ContractAddr.from(address),
     launchBlock: 0,
     type: "ERC4626" as const,
+    vaultType: {
+      type: VaultType.META_VAULT,
+      description: `Automatically diversify ${tokenSymbol} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring ${tokenSymbol} Rewards are auto-compounded as well.`
+    },
     depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === tokenSymbol)!
     ],
     protocols: [_protocol],
     auditUrl: AUDIT_URL,
+    curator: UnwrapLabsCurator,
     settings: createVesuRebalanceSettings(tokenSymbol),
     risk: getVesuRebalanceRisk(),
     additionalInfo: {
@@ -1066,10 +1072,14 @@ const createVesuRebalanceStrategy = (
     faqs,
     contractDetails: [],
     investmentSteps: [],
-    tags: [StrategyTag.VESU],
-    category: StrategyCategory.ALL,
+    tags: [],
     security: VESU_SECURITY,
     redemptionInfo: VESU_REDEMPTION_INFO,
+    discontinuationInfo: {
+        info: "This strategy has been deprecated and is no longer accepting new deposits."
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null,
 });
 
 // Shared security & redemption metadata for all Vesu strategies
@@ -1080,7 +1090,7 @@ const VESU_SECURITY = {
     contractLink: "https://github.com/trovesfi/troves-contracts",
   },
   accessControl: {
-    type: AccessControlType.STANDARD_ACCOUNT,
+    type: AccessControlType.ROLE_BASED_ACCESS,
     addresses: [ContractAddr.from("0x0")],
     timeLock: "2 Days",
   },
@@ -1088,6 +1098,8 @@ const VESU_SECURITY = {
 
 const VESU_REDEMPTION_INFO = {
   instantWithdrawalVault: InstantWithdrawalVault.YES,
+  redemptionsInfo: [],
+  alerts: [],
 };
 
 const faqs: FAQ[] = [
@@ -1143,21 +1155,25 @@ const faqs: FAQ[] = [
 export const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[] =
     [
         createVesuRebalanceStrategy(
+            'strk',
             "Vesu Fusion STRK",
             "STRK",
             "0x7fb5bcb8525954a60fde4e8fb8220477696ce7117ef264775a1770e23571929"
         ),
         createVesuRebalanceStrategy(
+            'eth',
             "Vesu Fusion ETH",
             "ETH",
             "0x5eaf5ee75231cecf79921ff8ded4b5ffe96be718bcb3daf206690ad1a9ad0ca"
         ),
         createVesuRebalanceStrategy(
+            'usdc',
             "Vesu Fusion USDC.e",
             "USDC.e",
             "0xa858c97e9454f407d1bd7c57472fc8d8d8449a777c822b41d18e387816f29c"
         ),
         createVesuRebalanceStrategy(
+            'usdt',
             "Vesu Fusion USDT",
             "USDT",
             "0x115e94e722cfc4c77a2f15c4aefb0928c1c0029e5a57570df24c650cb7cec2c"
@@ -1171,8 +1187,7 @@ VesuRebalanceStrategies.forEach((s) => {
     address: s.address,
     name: "Vault",
     sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/vesu_rebalance"
-  }, 
-  ...COMMON_CONTRACTS];
+  }];
   // set docs link
   s.docs = "https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults"