@strkfarm/sdk 2.0.0-dev.26 → 2.0.0-dev.28

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<HyperLSTStrategySettings> {
+    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

@@ -9,4 +9,9 @@ export * from './universal-lst-muliplier-strategy';
 export * from './vesu-extended-strategy/vesu-extended-strategy';
 export * from './vesu-extended-strategy/utils/config.runtime';
 export * from './vesu-extended-strategy/utils/helper';
-export * from './vesu-extended-strategy/types/transaction-metadata';
+export * from './vesu-extended-strategy/types/transaction-metadata';
+export * from './vesu-extended-strategy/services/executionService';
+export * from './vesu-extended-strategy/services/extended-vesu-state-manager';
+export * from "./registry";
+export * from "./factory";
+export * from "./types";

package/src/strategies/registry.ts

@@ -0,0 +1,239 @@
+import { getAllStrategyTags, IStrategyMetadata } from "@/interfaces";
+import {
+  EkuboCLVaultStrategies,
+  CLVaultStrategySettings,
+} from "./ekubo-cl-vault";
+import {
+  HyperLSTStrategies,
+  HyperLSTStrategySettings,
+} from "./universal-lst-muliplier-strategy";
+import { UniversalStrategies } from "./universal-strategy";
+import { VesuRebalanceStrategies } from "./vesu-rebalance";
+import { SenseiStrategies } from "./sensei";
+
+/**
+ * Filter option definition
+ */
+export interface FilterOption {
+  id: string;
+  label: string;
+  icon?: string;
+}
+
+/**
+ * Strategy filter metadata - defines what filters are available
+ */
+export interface StrategyFilterMetadata {
+  assets: FilterOption[];
+  protocols: FilterOption[];
+  quickFilters: FilterOption[];
+}
+
+/**
+ * Strategy type enum
+ */
+export enum StrategyType {
+  EKUBO_CL = "ekubo",
+  UNIVERSAL = "universal",
+  HYPER_LST = "hyper-lst",
+  VESU_REBALANCE = "vesu-rebalance",
+  SENSEI = "sensei",
+}
+
+/**
+ * Strategy metadata extracted from IStrategyMetadata
+ */
+export interface StrategyMetadata {
+  id: string;
+  name: string;
+  type: StrategyType;
+  assets: string[]; // Token symbols (e.g., ["STRK", "USDC"])
+  protocols: string[]; // Protocol names (e.g., ["Ekubo"])
+  tags: string[];
+  curator?: { name: string; logo: string };
+  isRetired: boolean;
+}
+
+/**
+ * Strategy registry entry
+ */
+export interface StrategyRegistryEntry<T = any> {
+  metadata: IStrategyMetadata<T>;
+  type: StrategyType;
+}
+
+/**
+ * Extract assets from strategy metadata
+ */
+function extractAssets(metadata: IStrategyMetadata<any>): string[] {
+  const assets: string[] = [];
+  if (metadata.depositTokens) {
+    metadata.depositTokens.forEach((token) => {
+      const symbol = token.symbol?.toLowerCase() || "";
+      if (symbol) {
+        assets.push(symbol);
+      }
+    });
+  }
+  return assets;
+}
+
+/**
+ * Check if strategy is retired
+ */
+function isRetired(metadata: IStrategyMetadata<any>): boolean {
+  // Check liveStatus if available
+  const liveStatus = (metadata as any).liveStatus?.toLowerCase() || "";
+  return liveStatus === "retired" || liveStatus === "coming soon";
+}
+
+/**
+ * Build strategy registry from SDK strategies
+ */
+export function buildStrategyRegistry(): StrategyRegistryEntry[] {
+  const registry: StrategyRegistryEntry[] = [];
+
+  // Register Ekubo CL Vault strategies
+  if (EkuboCLVaultStrategies && Array.isArray(EkuboCLVaultStrategies)) {
+    EkuboCLVaultStrategies.forEach((metadata) => {
+      registry.push({
+        metadata,
+        type: StrategyType.EKUBO_CL,
+      });
+    });
+  }
+
+  // Register Universal strategies
+  if (UniversalStrategies && Array.isArray(UniversalStrategies)) {
+    UniversalStrategies.forEach((metadata) => {
+      registry.push({
+        metadata,
+        type: StrategyType.UNIVERSAL,
+      });
+    });
+  }
+
+  // Register Hyper LST strategies
+  if (HyperLSTStrategies && Array.isArray(HyperLSTStrategies)) {
+    HyperLSTStrategies.forEach((metadata) => {
+      registry.push({
+        metadata,
+        type: StrategyType.HYPER_LST,
+      });
+    });
+  }
+
+  // Register Vesu Rebalance strategies
+  if (VesuRebalanceStrategies && Array.isArray(VesuRebalanceStrategies)) {
+    VesuRebalanceStrategies.forEach((metadata) => {
+      registry.push({
+        metadata: metadata as any, // Type cast for compatibility
+        type: StrategyType.VESU_REBALANCE,
+      });
+    });
+  }
+
+  // Register Sensei strategies
+  if (SenseiStrategies && Array.isArray(SenseiStrategies)) {
+    SenseiStrategies.forEach((metadata) => {
+      registry.push({
+        metadata: metadata as any,
+        type: StrategyType.SENSEI,
+      });
+    });
+  }
+
+  return registry;
+}
+
+/**
+ * Get all strategy metadata from registry
+ */
+export function getAllStrategyMetadata(): StrategyMetadata[] {
+  const registry = buildStrategyRegistry();
+  return registry.map((entry) => {
+    const metadataAny = entry.metadata as any;
+    return {
+      id: metadataAny.id || entry.metadata.name || "unknown",
+      name: entry.metadata.name || "Unknown Strategy",
+      type: entry.type,
+      assets: extractAssets(entry.metadata),
+      protocols: entry.metadata.protocols.map(p => p.name.toLowerCase()),
+      tags: entry.metadata.tags || [],
+      curator: entry.metadata.curator,
+      isRetired: isRetired(entry.metadata),
+    };
+  });
+}
+
+/**
+ * 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 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)
+ */
+export function getLiveStrategies(): StrategyRegistryEntry[] {
+  const registry = buildStrategyRegistry();
+  return registry.filter((entry) => !isRetired(entry.metadata));
+}
+
+/**
+ * Get strategies by type
+ */
+export function getStrategiesByType(
+  type: StrategyType,
+): StrategyRegistryEntry[] {
+  const registry = buildStrategyRegistry();
+  return registry.filter((entry) => entry.type === type);
+}