@strkfarm/sdk 2.0.0-staging.1 → 2.0.0-staging.10

package/src/strategies/factory.ts

@@ -0,0 +1,159 @@
+import { IConfig, IStrategyMetadata } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
+import {
+    UniversalStrategy,
+    UniversalStrategySettings
+} from "./universal-strategy";
+import { EkuboCLVault, CLVaultStrategySettings } from "./ekubo-cl-vault";
+import {
+    UniversalLstMultiplierStrategy,
+    HyperLSTStrategySettings
+} from "./universal-lst-muliplier-strategy";
+import { VesuRebalance, VesuRebalanceSettings } from "./vesu-rebalance";
+import { SenseiVault, SenseiVaultSettings } from "./sensei";
+
+export enum FactoryStrategyType {
+    UNIVERSAL = "UNIVERSAL",
+    EKUBO_CL = "EKUBO_CL",
+    HYPER_LST = "HYPER_LST",
+    VESU_REBALANCE = "VESU_REBALANCE",
+    SENSEI = "SENSEI"
+}
+
+export function createUniversalStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<UniversalStrategySettings>
+): UniversalStrategy<UniversalStrategySettings> {
+    return new UniversalStrategy(config, pricer, metadata);
+}
+
+export function createEkuboCLStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<CLVaultStrategySettings>
+): EkuboCLVault {
+    return new EkuboCLVault(config, pricer, metadata);
+}
+
+export function createHyperLSTStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<HyperLSTStrategySettings>
+): UniversalLstMultiplierStrategy {
+    return new UniversalLstMultiplierStrategy(config, pricer, metadata);
+}
+
+export function createVesuRebalanceStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<VesuRebalanceSettings>
+): VesuRebalance {
+    return new VesuRebalance(config, pricer, metadata);
+}
+
+export function createSenseiStrategy(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<SenseiVaultSettings>
+): SenseiVault {
+    return new SenseiVault(config, pricer, metadata);
+}
+
+/**
+ * Determines the strategy type from metadata by inspecting the additionalInfo structure
+ */
+export function getStrategyTypeFromMetadata(
+    metadata: IStrategyMetadata<any>
+): FactoryStrategyType {
+    const info = metadata.additionalInfo;
+
+    // Check for HyperLST (extends UniversalStrategySettings with borrowable_assets and underlyingToken)
+    if (info && "borrowable_assets" in info && "underlyingToken" in info) {
+        return FactoryStrategyType.HYPER_LST;
+    }
+
+    // Check for EkuboCL (has newBounds, rebalanceConditions, quoteAsset)
+    if (
+        info &&
+        ("newBounds" in info || typeof info.newBounds !== "undefined") &&
+        "rebalanceConditions" in info &&
+        "quoteAsset" in info
+    ) {
+        return FactoryStrategyType.EKUBO_CL;
+    }
+
+    // Check for Sensei (has mainToken, secondaryToken, targetHfBps)
+    if (
+        info &&
+        "mainToken" in info &&
+        "secondaryToken" in info &&
+        "targetHfBps" in info
+    ) {
+        return FactoryStrategyType.SENSEI;
+    }
+
+    // Check for VesuRebalance (has feeBps, but simpler structure)
+    if (info && "feeBps" in info && Object.keys(info).length <= 2) {
+        return FactoryStrategyType.VESU_REBALANCE;
+    }
+
+    // Check for Universal (has vaultAddress, manager, vaultAllocator, etc.)
+    if (
+        info &&
+        "vaultAddress" in info &&
+        "manager" in info &&
+        "vaultAllocator" in info
+    ) {
+        return FactoryStrategyType.UNIVERSAL;
+    }
+
+    throw new Error(
+        `Unable to determine strategy type from metadata: ${metadata.id}`
+    );
+}
+
+/**
+ * Generic factory function that creates SDK strategy instances based on type
+ */
+export function createStrategy(
+    type: FactoryStrategyType,
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<any>
+) {
+    switch (type) {
+        case FactoryStrategyType.UNIVERSAL:
+            return createUniversalStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<UniversalStrategySettings>
+            );
+        case FactoryStrategyType.EKUBO_CL:
+            return createEkuboCLStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<CLVaultStrategySettings>
+            );
+        case FactoryStrategyType.HYPER_LST:
+            return createHyperLSTStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<HyperLSTStrategySettings>
+            );
+        case FactoryStrategyType.VESU_REBALANCE:
+            return createVesuRebalanceStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<VesuRebalanceSettings>
+            );
+        case FactoryStrategyType.SENSEI:
+            return createSenseiStrategy(
+                config,
+                pricer,
+                metadata as IStrategyMetadata<SenseiVaultSettings>
+            );
+        default:
+            throw new Error(`Unknown strategy type: ${type}`);
+    }
+}

package/src/strategies/index.ts

@@ -7,3 +7,4 @@ export * from './universal-adapters';
 export * from './universal-strategy';
 export * from './universal-lst-muliplier-strategy';
 export * from "./registry";
+export * from "./factory";

package/src/strategies/registry.ts

@@ -1,9 +1,4 @@
-/**
- * Strategy Registry - Centralized strategy metadata and filtering
- * Provides utilities for getting strategy lists, metadata, and filter options
- */
-
-import { IStrategyMetadata } from "@/interfaces";
+import { getAllStrategyTags, IStrategyMetadata } from "@/interfaces";
 import {
   EkuboCLVaultStrategies,
   CLVaultStrategySettings,
@@ -31,7 +26,6 @@ export interface FilterOption {
 export interface StrategyFilterMetadata {
   assets: FilterOption[];
   protocols: FilterOption[];
-  categories: FilterOption[];
   quickFilters: FilterOption[];
 }
 
@@ -55,7 +49,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;
@@ -166,7 +159,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),
@@ -178,62 +170,55 @@ export function getAllStrategyMetadata(): StrategyMetadata[] {
  * Get filter metadata - defines available filters and their options
  */
 export function getFilterMetadata(): StrategyFilterMetadata {
-  const allMetadata = getAllStrategyMetadata();
-
-  // Extract unique assets
-  const assetSet = new Set<string>();
-  allMetadata.forEach((meta) => {
-    meta.assets.forEach((asset) => assetSet.add(asset));
-  });
-  const assets: FilterOption[] = Array.from(assetSet)
-    .sort()
-    .map((id) => ({
-      id,
-      label: id.toUpperCase(),
-    }));
-
-  // Extract unique protocols
-  const protocolSet = new Set<string>();
-  allMetadata.forEach((meta) => {
-    meta.protocols.forEach((protocol) => protocolSet.add(protocol));
-  });
-  const protocols: FilterOption[] = Array.from(protocolSet)
-    .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",
-    }));
-
-  // Quick filters
-  const quickFilters: FilterOption[] = [
-    { id: "all", label: "All Strategies" },
-    { id: "btc", label: "BTC" },
-    { id: "meta-vaults", label: "Meta Vaults" },
-  ];
-
-  return {
-    assets,
-    protocols,
-    categories,
-    quickFilters,
-  };
-}
+    const allMetadata = getAllStrategyMetadata();
+  
+      // Extract unique assets
+      const assetSet = new Set<string>();
+      allMetadata.forEach((meta) => {
+          meta.assets.forEach((asset) => assetSet.add(asset));
+      });
+  
+      const allowedAssets = new Set(["eth", "btc", "strk", "usdt", "usdc"]);
+      const assets: FilterOption[] = Array.from(assetSet)
+          .filter((asset) => allowedAssets.has(asset.toLowerCase()))
+          .sort((a, b) => {
+              // Sort in specific order: ETH, BTC, STRK, USDT, USDC
+              const order = ["eth", "btc", "strk", "usdt", "usdc"];
+              const aIndex = order.indexOf(a.toLowerCase());
+              const bIndex = order.indexOf(b.toLowerCase());
+              if (aIndex === -1 && bIndex === -1) return 0;
+              if (aIndex === -1) return 1;
+              if (bIndex === -1) return -1;
+              return aIndex - bIndex;
+          })
+          .map((id) => ({
+              id,
+              label: id.toUpperCase()
+          }));
+  
+      // Extract unique protocols
+      const protocolSet = new Set<string>();
+      allMetadata.forEach((meta) => {
+          meta.protocols.forEach((protocol) => protocolSet.add(protocol));
+      });
+      const protocols: FilterOption[] = Array.from(protocolSet)
+          .sort()
+          .map((id) => ({
+              id,
+              label: id.charAt(0).toUpperCase() + id.slice(1)
+          }));
+  
+      const quickFilters: FilterOption[] = [
+          { id: "all", label: "All Strategies" },
+          ...getAllStrategyTags().map((tag) => ({ id: tag.toLowerCase().replaceAll(" ", "-"), label: tag })),
+      ];
+  
+      return {
+          assets,
+          protocols,
+          quickFilters
+      };
+  }
 
 /**
  * Get live strategies (filter out retired)
@@ -252,51 +237,3 @@ export function getStrategiesByType(
   const registry = buildStrategyRegistry();
   return registry.filter((entry) => entry.type === type);
 }
-
-/**
- * Get strategies by filter criteria
- */
-export interface StrategyFilterCriteria {
-  assets?: string[];
-  protocols?: string[];
-  categories?: string[];
-  showRetired?: boolean;
-}
-
-export function getFilteredStrategies(
-  criteria: StrategyFilterCriteria,
-): StrategyMetadata[] {
-  let allMetadata = getAllStrategyMetadata();
-
-  // Filter out retired strategies if not explicitly shown
-  if (!criteria.showRetired) {
-    allMetadata = allMetadata.filter((meta) => !meta.isRetired);
-  }
-
-  // Filter by assets
-  if (criteria.assets && criteria.assets.length > 0) {
-    allMetadata = allMetadata.filter((meta) =>
-      meta.assets.some((asset) =>
-        criteria.assets!.includes(asset.toLowerCase()),
-      ),
-    );
-  }
-
-  // Filter by protocols
-  if (criteria.protocols && criteria.protocols.length > 0) {
-    allMetadata = allMetadata.filter((meta) =>
-      meta.protocols.some((protocol) =>
-        criteria.protocols!.includes(protocol.toLowerCase()),
-      ),
-    );
-  }
-
-  // Filter by categories
-  if (criteria.categories && criteria.categories.length > 0) {
-    allMetadata = allMetadata.filter((meta) =>
-      criteria.categories!.includes(meta.category),
-    );
-  }
-
-  return allMetadata;
-}

package/src/strategies/sensei.ts

@@ -1,7 +1,7 @@
-import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyCategory, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault } from "@/interfaces";
+import { getNoRiskTags, highlightTextWithLinks, IConfig, IProtocol, IStrategyMetadata, RiskFactor, RiskType, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, VaultType } from "@/interfaces";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } 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 +11,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;
@@ -236,12 +238,111 @@ export class SenseiVault extends BaseStrategy<
     return settings;
   };
 
+  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> {
@@ -453,9 +554,10 @@ const FAQS = [
 export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
   [
     {
+      id: "xstrk_sensei",
       name: "xSTRK Sensei",
       description: highlightTextWithLinks(
-        senseiDescription.replaceAll('{{token1}}', 'STRK').replaceAll('{{token2}}', 'xSTRK'),
+        senseiDescription.replace('{{token1}}', 'STRK').replace('{{token2}}', 'xSTRK'),
         [{
           highlight: "Endur",
           link: "https://endur.fi"
@@ -472,11 +574,37 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
       ),
       launchBlock: 1053811,
       type: "Other",
+      curator: {
+        name: "Unwrap Labs",
+        logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
+      },
+      vaultType: {
+        type: VaultType.FARMING,
+        description: "this is a yield farming vault"
+      },
       depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
       ],
       protocols: [endurProtocol, vesuProtocol],
-      maxTVL: new Web3Number("1500000", 18),
+      settings: {
+        maxTVL: new Web3Number("1500000", 18),
+        alerts: [
+            {
+                type: "info",
+                text: "Depeg-risk: If xSTRK price on DEXes deviates from expected price, you may lose money or may have to wait for the price to recover.",
+                tab: "all"
+            }
+        ],
+        liveStatus: StrategyLiveStatus.ACTIVE,
+        isPaused: false,
+        isInMaintenance: false,
+        isAudited: false,
+        isInstantWithdrawal: true,
+        isTransactionHistDisabled: true,
+        quoteToken: Global.getDefaultTokens().find(
+            (t) => t.symbol === "STRK"
+        )!
+    },
       risk: {
         riskFactor: _riskFactor,
         netRisk:
@@ -500,8 +628,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: {

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

@@ -232,7 +232,8 @@ function getVesuMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams
 export const VesuPools = {
   Genesis: ContractAddr.from('0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28'),
   Re7xSTRK: ContractAddr.from('0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161'),
-  Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf')
+  Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf'),
+  Prime: ContractAddr.from('0x451fe483d5921a2919ddd81d0de6696669bccdacd859f72a4fba7656b97c3b5'),
 }
 
 export const extensionMap: {[key: string]: ContractAddr} = {};
@@ -587,7 +588,8 @@ export class VesuAdapter extends BaseAdapter {
     const assetConfig = isV2 ? _assetConfig : _assetConfig['0'];
     const timeDelta = assetConfig.last_updated;
     const lastFullUtilizationRate = assetConfig.last_full_utilization_rate;
-    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    const debtSharePrice = Web3Number.fromWei(assetConfig.last_rate_accumulator, 18);
+    const currentDebt = (new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals)).multipliedBy(debtSharePrice);
     const totalSupply = currentDebt.plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
 
     const ratePerSecond = BigInt(Math.round(maxBorrowAPY / 365 / 24 / 60 / 60 * Number(SCALE)));
@@ -596,7 +598,7 @@ export class VesuAdapter extends BaseAdapter {
    
     const maxDebtToHave = totalSupply.multipliedBy(Number(maxUtilisation) / 1e18);
     logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate currentDebt: ${currentDebt.toString()}, maxDebtToHave: ${maxDebtToHave.toString()}`);
-    return maxDebtToHave.minus(currentDebt);
+    return {maxDebtToHave: maxDebtToHave.minus(currentDebt), currentDebt: currentDebt, totalSupply: totalSupply};
   }
 
   async getLTVConfig(config: IConfig, blockNumber: BlockIdentifier = 'latest') {
@@ -745,7 +747,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;
 
@@ -891,4 +893,4 @@ export class VesuAdapter extends BaseAdapter {
     }
     throw new Error('Max utilization not found');
   }
-}
+}