@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

package/src/strategies/factory.ts

@@ -0,0 +1,165 @@
+/**
+ * SDK Strategy Factory
+ *
+ * Creates SDK strategy instances from metadata.
+ */
+
+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

@@ -1,11 +1,10 @@
-export * from './autoCompounderStrk';
-export * from './vesu-rebalance';
-export * from './ekubo-cl-vault';
-export * from './base-strategy';
-export * from './sensei';
-export * from './universal-adapters';
-export * from './universal-strategy';
-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 "./autoCompounderStrk";
+export * from "./vesu-rebalance";
+export * from "./ekubo-cl-vault";
+export * from "./base-strategy";
+export * from "./sensei";
+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

@@ -0,0 +1,268 @@
+import { 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[];
+    categories: 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"])
+    category: string; // Category (e.g., "BTC", "Meta Vaults")
+    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()
+            ),
+            category: entry.metadata.category || "",
+            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 === "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"
+        }));
+
+    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" }
+    ];
+
+    return {
+        assets,
+        protocols,
+        categories,
+        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);
+}