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

package/src/strategies/factory.ts

@@ -9,6 +9,7 @@ import {
     UniversalLstMultiplierStrategy,
     HyperLSTStrategySettings
 } from "./universal-lst-muliplier-strategy";
+import { YoLoVault, YoloVaultSettings } from "./yoloVault";
 import { VesuRebalance, VesuRebalanceSettings } from "./vesu-rebalance";
 import { SenseiVault, SenseiVaultSettings } from "./sensei";
 
@@ -17,7 +18,8 @@ export enum FactoryStrategyType {
     EKUBO_CL = "EKUBO_CL",
     HYPER_LST = "HYPER_LST",
     VESU_REBALANCE = "VESU_REBALANCE",
-    SENSEI = "SENSEI"
+    SENSEI = "SENSEI",
+    YOLO_VAULT = "YOLO_VAULT"
 }
 
 export function createUniversalStrategy(
@@ -36,6 +38,14 @@ export function createEkuboCLStrategy(
     return new EkuboCLVault(config, pricer, metadata);
 }
 
+export function createYoloVaultStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<YoloVaultSettings>
+): YoLoVault {
+    return new YoLoVault(config, pricer, metadata);
+}
+
 export function createHyperLSTStrategy(
     config: IConfig,
     pricer: PricerBase,
@@ -67,6 +77,10 @@ export function getStrategyTypeFromMetadata(
     metadata: IStrategyMetadata<any>
 ): FactoryStrategyType {
     const info = metadata.additionalInfo;
+ 
+    if (info && "mainToken" in info && "secondaryToken" in info && "minEpochDurationSeconds" in info && "feeBps" in info) {
+        return FactoryStrategyType.YOLO_VAULT;
+    }
 
     // Check for HyperLST (extends UniversalStrategySettings with borrowable_assets and underlyingToken)
     if (info && "borrowable_assets" in info && "underlyingToken" in info) {
@@ -153,6 +167,12 @@ export function createStrategy(
                 pricer,
                 metadata as IStrategyMetadata<SenseiVaultSettings>
             );
+        case FactoryStrategyType.YOLO_VAULT:
+            return createYoloVaultStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<YoloVaultSettings>
+            );
         default:
             throw new Error(`Unknown strategy type: ${type}`);
     }

package/src/strategies/index.ts

@@ -3,8 +3,10 @@ export * from './vesu-rebalance';
 export * from './ekubo-cl-vault';
 export * from './base-strategy';
 export * from './sensei';
+export * from './yoloVault';
 export * from './universal-adapters';
 export * from './universal-strategy';
 export * from './universal-lst-muliplier-strategy';
 export * from "./registry";
 export * from "./factory";
+export * from "./types";

package/src/strategies/registry.ts

@@ -1,4 +1,4 @@
-import { IStrategyMetadata } from "@/interfaces";
+import { getAllStrategyTags, IStrategyMetadata } from "@/interfaces";
 import {
   EkuboCLVaultStrategies,
   CLVaultStrategySettings,
@@ -10,6 +10,7 @@ import {
 import { UniversalStrategies } from "./universal-strategy";
 import { VesuRebalanceStrategies } from "./vesu-rebalance";
 import { SenseiStrategies } from "./sensei";
+import { YoloVaultStrategies } from "./yoloVault";
 
 /**
  * Filter option definition
@@ -26,7 +27,6 @@ export interface FilterOption {
 export interface StrategyFilterMetadata {
   assets: FilterOption[];
   protocols: FilterOption[];
-  categories: FilterOption[];
   quickFilters: FilterOption[];
 }
 
@@ -39,6 +39,7 @@ export enum StrategyType {
   HYPER_LST = "hyper-lst",
   VESU_REBALANCE = "vesu-rebalance",
   SENSEI = "sensei",
+  YOLO_VAULT = "yolo-vault",
 }
 
 /**
@@ -50,7 +51,6 @@ export interface StrategyMetadata {
   type: StrategyType;
   assets: string[]; // Token symbols (e.g., ["STRK", "USDC"])
   protocols: string[]; // Protocol names (e.g., ["Ekubo"])
-  category: string; // Category (e.g., "BTC", "Meta Vaults")
   tags: string[];
   curator?: { name: string; logo: string };
   isRetired: boolean;
@@ -145,6 +145,16 @@ export function buildStrategyRegistry(): StrategyRegistryEntry[] {
     });
   }
 
+  // Register Yolo Vault strategies
+  if (YoloVaultStrategies && Array.isArray(YoloVaultStrategies)) {
+    YoloVaultStrategies.forEach((metadata) => {
+      registry.push({
+        metadata: metadata as any,
+        type: StrategyType.YOLO_VAULT,
+      });
+    });
+  }
+
   return registry;
 }
 
@@ -161,7 +171,6 @@ export function getAllStrategyMetadata(): StrategyMetadata[] {
       type: entry.type,
       assets: extractAssets(entry.metadata),
       protocols: entry.metadata.protocols.map(p => p.name.toLowerCase()),
-      category: entry.metadata.category,
       tags: entry.metadata.tags || [],
       curator: entry.metadata.curator,
       isRetired: isRetired(entry.metadata),
@@ -208,41 +217,17 @@ export function getFilterMetadata(): StrategyFilterMetadata {
           .sort()
           .map((id) => ({
               id,
-              label:
-                  id === "meta-vaults"
-                      ? "Meta Vaults"
-                      : id.charAt(0).toUpperCase() + id.slice(1)
-          }));
-  
-      // Extract unique categories
-      const categorySet = new Set<string>();
-      allMetadata.forEach((meta) => {
-          if (meta.category) categorySet.add(meta.category);
-      });
-      const categories: FilterOption[] = Array.from(categorySet)
-          .sort()
-          .map((id) => ({
-              id,
-              label:
-                  id === "btc"
-                      ? "BTC"
-                      : id === "meta-vaults"
-                      ? "Meta Vaults"
-                      : "All"
+              label: id.charAt(0).toUpperCase() + id.slice(1)
           }));
   
       const quickFilters: FilterOption[] = [
           { id: "all", label: "All Strategies" },
-          { id: "btc", label: "BTC" },
-          { id: "ekubo", label: "Ekubo" },
-          { id: "endur", label: "Endur" },
-          { id: "meta-vaults", label: "Meta Vaults" }
+          ...getAllStrategyTags().map((tag) => ({ id: tag.toLowerCase().replaceAll(" ", "-"), label: tag })),
       ];
   
       return {
           assets,
           protocols,
-          categories,
           quickFilters
       };
   }

package/src/strategies/sensei.ts

@@ -1,7 +1,13 @@
-import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyCategory, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus } from "@/interfaces";
-import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, VaultType, UnwrapLabsCurator } from "@/interfaces";
+import {
+  BaseStrategy,
+  SingleActionAmount,
+  SingleTokenInfo,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { Call, Contract, uint256, BlockIdentifier } from "starknet";
+import { Call, Contract, num, uint256, BlockIdentifier } from "starknet";
 import SenseiABI from "@/data/sensei.abi.json";
 import { getTrovesEndpoint, logger } from "@/utils";
 import { Global } from "@/global";
@@ -11,6 +17,8 @@ import ERC20ABI from "@/data/erc20.abi.json";
 import { AvnuWrapper } from "@/modules";
 import { gql } from "@apollo/client";
 import apolloClient from "@/modules/apollo-client";
+import { VesuAdapter, VesuPools } from "./universal-adapters/vesu-adapter";
+import { LSTAPRService } from "@/modules/lst-apr";
 
 export interface SenseiVaultSettings {
   mainToken: TokenInfo;
@@ -92,7 +100,7 @@ export class SenseiVault extends BaseStrategy<
         tokenInfo: this.metadata.depositTokens[0],
       };
     } catch (error) {
-      console.error('Error fetching TVL:', error);
+      console.error(`[SDK] Error fetching TVL for ${this.metadata.id}:`, error);
       return {
         usdValue: 0,
         amount: new Web3Number('0', this.metadata.depositTokens[0].decimals),
@@ -236,12 +244,122 @@ export class SenseiVault extends BaseStrategy<
     return settings;
   };
 
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(
+    userTVL: SingleTokenInfo,
+    investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+  ): any {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
+
+  async netAPY(): Promise<number> {
+    try {
+      // Fetch Vesu pools and select the Re7 xSTRK pool
+      const { pools } = await VesuAdapter.getVesuPools();
+      const re7PoolId = VesuPools.Re7xSTRK;
+      const pool = pools.find((p: any) =>
+        ContractAddr.from(num.getHexString(p.id)).eq(re7PoolId),
+      );
+
+      if (!pool) {
+        logger.warn(`${SenseiVault.name}::netAPY - Re7 xSTRK pool not found`);
+        return 0;
+      }
+
+      const mainSymbol = this.metadata.additionalInfo.mainToken.symbol.toLowerCase(); // STRK
+      const secondarySymbol =
+        this.metadata.additionalInfo.secondaryToken.symbol.toLowerCase(); // xSTRK
+
+      const collateralAssetStats = pool.assets.find(
+        (a: any) => String(a.symbol).toLowerCase() === secondarySymbol,
+      )?.stats;
+      const debtAssetStats = pool.assets.find(
+        (a: any) => String(a.symbol).toLowerCase() === mainSymbol,
+      )?.stats;
+
+      if (!collateralAssetStats || !debtAssetStats) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Missing collateral/debt stats on Vesu pool`,
+        );
+        return 0;
+      }
+
+      // Base xSTRK lending APY from Vesu
+      const xstrkSupplyAPY =
+        Number(collateralAssetStats.supplyApy?.value || 0) / 1e18;
+
+      // STRK rewards APR on xSTRK collateral from Vesu
+      const strkRewardsAPR = collateralAssetStats.defiSpringSupplyApr
+        ? Number(collateralAssetStats.defiSpringSupplyApr.value || 0) / 1e18
+        : 0;
+
+      // STRK borrow APY from Vesu
+      const borrowAPY =
+        Number(debtAssetStats.borrowApr?.value || 0) / 1e18;
+
+      // LST APR for xSTRK from Endur (based on underlying STRK asset)
+      const lstAPY = await LSTAPRService.getLSTAPR(
+        this.metadata.additionalInfo.mainToken.address,
+      );
+
+      // Collateral APY = Vesu xSTRK supply + Endur xSTRK APR + STRK rewards
+      const collateralAPY = xstrkSupplyAPY + lstAPY + strkRewardsAPR;
+
+      const feeFactor = this.metadata.additionalInfo.feeBps / 10000; // convert bps to decimal
+      const feeAdjustedColAPY =
+        collateralAPY - strkRewardsAPR * feeFactor;
+
+      // Position info (collateral & debt in USD terms)
+      const { collateralUSDValue, debtUSDValue } =
+        await this.getPositionInfo();
+
+      const collateralUSD = Number(collateralUSDValue.toFixed(6));
+      const debtUSD = Number(debtUSDValue.toFixed(6));
+
+      // Compute expected leverage using the same math as app-side strategy
+      const targetHf = this.metadata.additionalInfo.targetHfBps / 10000;
+      const xSTRKPrice = await this.getSecondaryTokenPriceRelativeToMain();
+      const denominator = targetHf * xSTRKPrice - 0.87;
+      if (denominator <= 0) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Invalid denominator in leverage calc`,
+        );
+        return 0;
+      }
+      const borrowedSTRK = (0.87 * xSTRKPrice) / denominator;
+      const expectedLeverage = 1 + borrowedSTRK;
+      if (!Number.isFinite(expectedLeverage) || expectedLeverage <= 0) {
+        logger.warn(
+          `${SenseiVault.name}::netAPY - Non-positive or invalid expectedLeverage`,
+        );
+        return 0;
+      }
+
+      const payoff =
+        collateralUSD * feeAdjustedColAPY - debtUSD * borrowAPY;
+      const investment = collateralUSD - debtUSD;
+
+      if (investment === 0) {
+        return 0;
+      }
+
+      const netAPY = payoff / investment;
+      return Number.isFinite(netAPY) ? netAPY : 0;
+    } catch (error) {
+      logger.error(`${SenseiVault.name}::netAPY - Error`, error);
+      return 0;
+    }
+  }
+
   /**
    * Calculates user realized APY based on position growth accounting for deposits and withdrawals.
    * Returns the APY as a number.
+   * Not implemented for Sensei Strategy yet.
    */
   async getUserRealizedAPY(
-    userAddress: ContractAddr,
     blockIdentifier: BlockIdentifier = "latest",
     sinceBlocks = 600000
   ): Promise<number> {
@@ -387,7 +505,10 @@ export class SenseiVault extends BaseStrategy<
     return apy;
     */
   }
-    
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    return [await this.createApyCard(input)];
+  }
 }
 
 const senseiDescription = `Deposit your {{token1}} to automatically loop your funds via Endur ({{token2}}) and Vesu to create a delta neutral position. This strategy is designed to maximize your yield on {{token1}}. Your position is automatically adjusted periodically to maintain a healthy health factor. You receive a NFT as representation for your stake on Troves. You can withdraw anytime by redeeming your NFT for {{token1}}.`;
@@ -473,6 +594,11 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
       ),
       launchBlock: 1053811,
       type: "Other",
+      curator: UnwrapLabsCurator,
+      vaultType: {
+        type: VaultType.LOOPING,
+        description: "Creates leveraged looping position on xSTRK by borrowing STRK to increase yield"
+      },
       depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
       ],
@@ -486,7 +612,7 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
                 tab: "all"
             }
         ],
-        liveStatus: StrategyLiveStatus.ACTIVE,
+        liveStatus: StrategyLiveStatus.RETIRED,
         isPaused: false,
         isInMaintenance: false,
         isAudited: false,
@@ -519,8 +645,7 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
         "Repeat the process to loop your position",
         "Claim DeFi spring (STRK) rewards weekly and reinvest",
       ],
-      category: StrategyCategory.ALL,
-      tags: [StrategyTag.SENSEI],
+      tags: [StrategyTag.LEVERED],
       security: {
         auditStatus: AuditStatus.AUDITED,
         sourceCode: {
@@ -528,13 +653,33 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
           contractLink: "https://github.com/trovesfi/troves-contracts",
         },
         accessControl: {
-          type: AccessControlType.STANDARD_ACCOUNT,
+          type: AccessControlType.ROLE_BASED_ACCESS,
           addresses: [ContractAddr.from("0x0")],
           timeLock: "2 Days",
         },
       },
       redemptionInfo: {
         instantWithdrawalVault: InstantWithdrawalVault.YES,
+        redemptionsInfo: [],
+        alerts: [],
+      },
+      usualTimeToEarnings: "2 weeks",
+      usualTimeToEarningsDescription: "Strategy returns depend on LST price on DEXes. Even though the true price of LST on Endur increases continuously, the DEX price may lag sometimes, and historically is seen to rebase at least once every 2 hours. This is when you realise your earnings.",
+      points: [{
+        multiplier: 4,
+        logo: 'https://endur.fi/favicon.ico',
+        toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi.",
+      }],
+      discontinuationInfo: {
+        info: highlightTextWithLinks(
+          "This strategy is retired. All funds have been moved to Hyper xSTRK.",
+          [
+            {
+              highlight: "Hyper xSTRK",
+              link: "/strategy/hyper_xstrk",
+            },
+          ]
+        ),
       },
     },
-  ];
+  ];

package/src/strategies/types.ts

@@ -0,0 +1,4 @@
+export enum LSTPriceType {
+  ENDUR_PRICE = 'ENDUR_PRICE',
+  AVNU_PRICE = 'AVNU_PRICE'
+}

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -234,6 +234,25 @@ export const VesuPools = {
   Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161'),
   Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf'),
   Prime: ContractAddr.from('0x451fe483d5921a2919ddd81d0de6696669bccdacd859f72a4fba7656b97c3b5'),
+  Re7STRK: ContractAddr.from('0x01fcdacc1d8184eca7b472b5acbaf1500cec9d5683ca95fede8128b46c8f9cc2'),
+}
+
+export const VesuPoolMetadata = {
+  [VesuPools.Genesis.address]: {
+    name: 'Genesis',
+  },
+  [VesuPools.Re7xSTRK.address]: {
+    name: 'Re7 xSTRK',
+  },
+  [VesuPools.Re7xBTC.address]: {
+    name: 'Re7 xBTC',
+  },
+  [VesuPools.Prime.address]: {
+    name: 'Prime',
+  },
+  [VesuPools.Re7STRK.address]: {
+    name: 'Re7 STRK',
+  },
 }
 
 export const extensionMap: {[key: string]: ContractAddr} = {};
@@ -418,14 +437,14 @@ export class VesuAdapter extends BaseAdapter {
     }
   }
 
-  getVesuModifyDelegationAdapter = (id: string): LeafAdapterFn<VesuModifyDelegationCallParams> => {
+  getVesuModifyDelegationAdapter = (id: string, delegatee: ContractAddr): LeafAdapterFn<VesuModifyDelegationCallParams> => {
     return () => {
       const { addr: VESU_SINGLETON, isV2 } = getVesuSingletonAddress(this.config.poolId);
       const packedArguments: bigint[] = isV2 ? [
-        toBigInt(this.VESU_MULTIPLY.toString()), // v2
+        toBigInt(delegatee.toString()), // v2
       ] : [
         this.config.poolId.toBigInt(),
-        toBigInt(this.VESU_MULTIPLY_V1.toString()), // v1
+        toBigInt(delegatee.toString()), // v1
       ];
       const output = this.constructSimpleLeafData({
         id: id,
@@ -434,29 +453,31 @@ export class VesuAdapter extends BaseAdapter {
         packedArguments
       }, isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS);
 
-      return { leaf: output, callConstructor: this.getVesuModifyDelegationCall.bind(this) };
+      return { leaf: output, callConstructor: this.getVesuModifyDelegationCall(delegatee).bind(this) };
     }
   }
 
-  getVesuModifyDelegationCall = (params: VesuModifyDelegationCallParams): ManageCall => {
-    const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
-    const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
-    const call = contract.populate('modify_delegation', isV2 ? {
-      delegatee: this.VESU_MULTIPLY.toBigInt(),
-      delegation: params.delegation,
-    } : {
-      pool_id: this.config.poolId.toBigInt(),
-      delegatee: this.VESU_MULTIPLY_V1.toBigInt(),
-      delegation: params.delegation,
-    });
-    return {
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
-      call: {
-        contractAddress: VESU_SINGLETON,
-        selector: hash.getSelectorFromName('modify_delegation'),
-        calldata: [
-          ...call.calldata as bigint[]
-        ]
+  getVesuModifyDelegationCall = (delegatee: ContractAddr) => {
+    return (params: VesuModifyDelegationCallParams) => {
+      const VESU_SINGLETON = getVesuSingletonAddress(this.config.poolId).addr;
+      const { contract, isV2 } = this.getVesuSingletonContract(getMainnetConfig(), this.config.poolId);
+      const call = contract.populate('modify_delegation', isV2 ? {
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      } : {
+        pool_id: this.config.poolId.toBigInt(),
+        delegatee: delegatee.toBigInt(),
+        delegation: params.delegation,
+      });
+      return {
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+        call: {
+          contractAddress: VESU_SINGLETON,
+          selector: hash.getSelectorFromName('modify_delegation'),
+          calldata: [
+            ...call.calldata as bigint[]
+          ]
+        }
       }
     }
   }
@@ -654,12 +675,12 @@ export class VesuAdapter extends BaseAdapter {
       amount: collateralAmount,
       token: this.config.collateral,
       usdValue: collateralAmount.multipliedBy(token1Price.price).toNumber(),
-      remarks: "Collateral"
+      remarks: `Collateral - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }, {
       amount: debtAmount,
       token: this.config.debt,
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
-      remarks: "Debt"
+      remarks: `Debt - ${VesuPoolMetadata[this.config.poolId.address].name} pool`
     }];
     this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
     return value;
@@ -747,7 +768,7 @@ export class VesuAdapter extends BaseAdapter {
       let pools: any[] = [];
       try {
         const data = await getAPIUsingHeadlessBrowser(
-          `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+          `${ENDPOINTS.VESU_BASE}/pools`
         );
         pools = data.data;
 
@@ -893,4 +914,4 @@ export class VesuAdapter extends BaseAdapter {
     }
     throw new Error('Max utilization not found');
   }
-}
+}