@strkfarm/sdk 2.0.0-staging.7 → 2.0.0-staging.70

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Contract, Uint256, Call, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import { Uint256, RpcProvider, BlockIdentifier, Contract, Call, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import BigNumber from 'bignumber.js';
 import React, { ReactNode } from 'react';
 import { Quote, AvnuOptions } from '@avnu/avnu-sdk';
 import { HexString, BytesLike } from '@ericnordelo/strk-merkle-tree/dist/bytes';
@@ -31,10 +31,12 @@ declare class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
         mag: bigint;
         sign: 0 | 1;
     };
+    toUint256(): starknet.Uint256;
 }
 
 declare class Web3Number extends _Web3Number<Web3Number> {
     static fromWei(weiNumber: string | number, decimals: number): Web3Number;
+    static fromUint256(uint256Value: Uint256): Web3Number;
 }
 
 /**
@@ -107,6 +109,7 @@ interface TokenInfo {
     displayDecimals: number;
     priceProxySymbol?: string;
     priceCheckAmount?: number;
+    dontPrice?: boolean;
 }
 declare enum Network {
     mainnet = "mainnet",
@@ -123,22 +126,22 @@ interface IProtocol {
     name: string;
     logo: string;
 }
-declare enum StrategyCategory {
-    ALL = "all",
-    BTC = "btc",
-    META_VAULTS = "meta-vaults"
+interface ICurator {
+    name: string;
+    logo: string;
 }
 declare enum StrategyTag {
-    EKUBO = "Ekubo",
-    EVERGREEN = "Evergreen",
-    HYPER_LST = "Hyper-LST",
-    VESU = "Vesu",
-    SENSEI = "Sensei",
-    ENDUR = "Endur",
+    META_VAULT = "Meta Vaults",
+    LEVERED = "Maxx",
+    AUTOMATED_LP = "Ekubo",
     BTC = "BTC"
 }
 declare enum VaultType {
-    FARMING = "farming"
+    LOOPING = "Looping",
+    META_VAULT = "Meta Vault",
+    DELTA_NEUTRAL = "Delta Neutral",
+    AUTOMATED_LP = "Automated LP",
+    TVA = "Troves Value Averaging"
 }
 declare enum AuditStatus {
     AUDITED = "Audited",
@@ -150,7 +153,8 @@ declare enum SourceCodeType {
 }
 declare enum AccessControlType {
     MULTISIG_ACCOUNT = "Multisig Account",
-    STANDARD_ACCOUNT = "Standard Account"
+    STANDARD_ACCOUNT = "Standard Account",
+    ROLE_BASED_ACCESS = "Role Based Access"
 }
 declare enum InstantWithdrawalVault {
     YES = "Yes",
@@ -163,21 +167,20 @@ interface SourceCodeInfo {
 interface AccessControlInfo {
     type: AccessControlType;
     addresses: ContractAddr[];
-    timeLock: string;
+    timeLock?: string;
 }
 interface SecurityMetadata {
     auditStatus: AuditStatus;
     sourceCode: SourceCodeInfo;
     accessControl: AccessControlInfo;
 }
-interface RedemptionExpectedTime {
-    upto1M: string;
-    upto10M: string;
-    above10M: string;
-}
 interface RedemptionInfo {
     instantWithdrawalVault: InstantWithdrawalVault;
-    expectedRedemptionTime?: RedemptionExpectedTime;
+    redemptionsInfo: {
+        title: string;
+        description: string;
+    }[];
+    alerts: StrategyAlert[];
 }
 declare enum FlowChartColors {
     Green = "purple",
@@ -192,7 +195,8 @@ declare enum StrategyLiveStatus {
     ACTIVE = "Active",
     NEW = "New",
     COMING_SOON = "Coming Soon",
-    RETIRED = "Retired",
+    DEPRECATED = "Deprecated",// active but not recommended
+    RETIRED = "Retired",// not active anymore
     HOT = "Hot & New \uD83D\uDD25"
 }
 interface StrategyAlert {
@@ -201,7 +205,6 @@ interface StrategyAlert {
     tab: "all" | "deposit" | "withdraw";
 }
 interface StrategySettings {
-    maxTVL?: Web3Number;
     liveStatus?: StrategyLiveStatus;
     isPaused?: boolean;
     isInMaintenance?: boolean;
@@ -216,6 +219,10 @@ interface StrategySettings {
     alerts?: StrategyAlert[];
     tags?: StrategyTag[];
 }
+interface StrategyApyHistoryUIConfig {
+    showApyHistory?: boolean;
+    noApyHistoryMessage?: string;
+}
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
@@ -226,6 +233,19 @@ interface IStrategyMetadata<T> {
     id: string;
     name: string;
     description: string | React.ReactNode;
+    /**
+     * Optional UI sort priority. Higher shows earlier.
+     * Intended for pinning flagship parent vaults (e.g. BTC above STRK).
+     */
+    priority?: number;
+    /**
+     * Optional UI config for the variant intro popup (strategy page).
+     * Should be identical across strategies that share the same `parentId`.
+     */
+    variantIntro?: {
+        title: string;
+        description: string;
+    };
     address: ContractAddr;
     launchBlock: number;
     type: "ERC4626" | "ERC721" | "Other";
@@ -242,6 +262,7 @@ interface IStrategyMetadata<T> {
         notARisks: RiskType[];
     };
     apyMethodology?: string;
+    realizedApyMethodology?: string;
     additionalInfo: T;
     contractDetails: {
         address: ContractAddr;
@@ -256,16 +277,20 @@ interface IStrategyMetadata<T> {
     }[];
     docs?: string;
     investmentSteps: string[];
-    curator?: {
-        name: string;
-        logo: string;
-    };
+    curator?: ICurator;
     isPreview?: boolean;
-    category: StrategyCategory;
     tags?: StrategyTag[];
     security: SecurityMetadata;
     redemptionInfo: RedemptionInfo;
+    usualTimeToEarnings: null | string;
+    usualTimeToEarningsDescription: null | string;
+    discontinuationInfo?: {
+        date?: Date;
+        reason?: React.ReactNode | string;
+        info?: React.ReactNode | string;
+    };
     settings?: StrategySettings;
+    apyHistoryUIConfig?: StrategyApyHistoryUIConfig;
     actions?: Array<{
         name?: string;
         pool?: {
@@ -285,6 +310,8 @@ interface IStrategyMetadata<T> {
         amount?: string | number;
         isDeposit?: boolean;
     }>;
+    parentId?: string;
+    parentName?: string;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -297,6 +324,8 @@ interface IInvestmentFlow {
     style?: any;
 }
 declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
+declare const getStrategyTagDesciption: (tag: StrategyTag) => string;
+declare const getAllStrategyTags: () => StrategyTag[];
 declare const getRiskExplaination: (riskType: RiskType) => "The risk of the market moving against the position." | "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them." | "The risk of losing funds due to the position being liquidated." | "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position." | "The risk of the oracle being manipulated or incorrect." | "The risk of the smart contract being vulnerable to attacks." | "The risk of technical issues e.g. backend failure." | "The risk of the counterparty defaulting e.g. bad debt on lending platforms." | "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
 declare const getRiskColor: (risk: RiskFactor) => "light_green_2" | "yellow" | "red";
 declare const getNoRiskTags: (risks: RiskFactor[]) => RiskType[];
@@ -337,6 +366,7 @@ declare const Protocols: {
     ENDUR: IProtocol;
     EXTENDED: IProtocol;
 };
+declare const UnwrapLabsCurator: ICurator;
 
 interface ILendingMetadata {
     name: string;
@@ -397,18 +427,41 @@ declare abstract class PricerBase {
     getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
 }
 
+/**
+ * Polls Avnu impulse tokens API and keeps USD prices in memory for configured tokens.
+ * Price timestamp is set when each poll request completes.
+ */
+declare class PricerAvnuApi extends PricerBase {
+    protected prices: {
+        [key: string]: PriceInfo;
+    };
+    readonly refreshInterval = 15000;
+    readonly staleTime: number;
+    private pollTimer;
+    private loading;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    start(): void;
+    stop(): void;
+    isStale(timestamp: Date): boolean;
+    hasPrice(tokenSymbol: string): boolean;
+    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    protected _loadPrices(): Promise<void>;
+}
+
 interface PriceInfo {
     price: number;
     timestamp: Date;
 }
+type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
 declare class Pricer extends PricerBase {
     protected prices: {
         [key: string]: PriceInfo;
     };
     refreshInterval: number;
     staleTime: number;
+    protected readonly avnuApiPricer: PricerAvnuApi;
     protected methodToUse: {
-        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu';
+        [tokenSymbol: string]: PriceMethod;
     };
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -423,7 +476,9 @@ declare class Pricer extends PricerBase {
     assertNotStale(timestamp: Date, tokenName: string): void;
     getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
     protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
-    _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
+    _getPrice(token: TokenInfo): Promise<number>;
+    protected _tryPriceMethod(token: TokenInfo, method: PriceMethod): Promise<number>;
+    _getPriceAvnuApi(token: TokenInfo): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
     _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
     _getAvnuPrice(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
@@ -494,6 +549,7 @@ declare class ERC20 {
     contract(addr: string | ContractAddr): Contract;
     balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
     allowance(token: string | ContractAddr, owner: string | ContractAddr, spender: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
+    approve(token: string | ContractAddr, spender: string | ContractAddr, amount: Web3Number): starknet.Call;
 }
 
 interface Route {
@@ -591,6 +647,8 @@ interface DualTokenInfo {
     token0: SingleTokenInfo;
     token1: SingleTokenInfo;
 }
+type StrategyInputMode = "single" | "dual";
+type InputModeFromAction<T> = T extends DualActionAmount ? "dual" : "single";
 interface NetAPYSplit {
     apy: number;
     id: string;
@@ -599,22 +657,75 @@ interface NetAPYDetails {
     net: number;
     splits: NetAPYSplit[];
 }
+type UserPositionCardSubValueColor = "default" | "positive" | "negative" | "info";
+interface UserPositionCard {
+    title: string;
+    value: string;
+    tooltip?: string;
+    subValue?: string;
+    subValueColor?: UserPositionCardSubValueColor;
+}
+interface UserPositionCardsInput {
+    user: ContractAddr;
+    investmentFlows?: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>;
+    usualTimeToEarnings?: string | null;
+    usualTimeToEarningsDescription?: string | null;
+}
 interface CacheData {
     timestamp: number;
     ttl: number;
     data: any;
 }
-declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
+declare class BaseStrategy<TVLInfo, DepositActionInfo, WithdrawActionInfo = DepositActionInfo> extends CacheClass {
     readonly config: IConfig;
     readonly cache: Map<string, CacheData>;
-    constructor(config: IConfig);
+    private readonly _depositInputMode;
+    private readonly _withdrawInputMode;
+    constructor(config: IConfig, inputModes?: {
+        depositInputMode?: InputModeFromAction<DepositActionInfo>;
+        withdrawInputMode?: InputModeFromAction<WithdrawActionInfo>;
+    });
+    depositInputMode(): InputModeFromAction<DepositActionInfo>;
+    withdrawInputMode(): InputModeFromAction<WithdrawActionInfo>;
     getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<TVLInfo>;
     getTVL(): Promise<TVLInfo>;
-    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    depositCall(amountInfo: DepositActionInfo, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: WithdrawActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
     getVaultPositions(): Promise<VaultPosition[]>;
-    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | NetAPYDetails>;
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | string | NetAPYDetails>;
     getPendingRewards(): Promise<HarvestInfo[]>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]>;
+    getMaxTVL(): Promise<Web3Number>;
+    protected formatTokenAmountForCard(amount: Web3Number, tokenInfo: TokenInfo): string;
+    protected formatPercentForCard(value: number): string;
+    protected formatUSDForCard(value: number): string;
+    protected getSubValueColorFromSignedNumber(value: number): UserPositionCardSubValueColor;
+    /**
+     * Calculate lifetime earnings for a user based on provided data from client
+     * Formula: lifetimeEarnings = currentValue + totalWithdrawals - totalDeposits
+     *
+     * @param userTVL - The user's current TVL (SingleTokenInfo with amount, usdValue, tokenInfo)
+     * @param investmentFlows - Array of investment flow transactions from client
+     * @returns Object containing lifetime earnings, current value, and total deposits/withdrawals
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): {
+        tokenInfo: SingleTokenInfo;
+        lifetimeEarnings: Web3Number;
+        currentValue: Web3Number;
+        totalDeposits: Web3Number;
+        totalWithdrawals: Web3Number;
+    };
 }
 
 interface PoolProps {
@@ -900,17 +1011,32 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
     rebalanceCall(newBounds: EkuboBounds, swapParams: SwapInfo): Call[];
     handleUnusedCall(swapParams: SwapInfo): Call[];
     handleFeesCall(): Call[];
-    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m'): Promise<{
+    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m' | '6m', range?: {
+        startTimestamp?: number;
+        endTimestamp?: number;
+    }): Promise<{
         summary: DualTokenInfo;
         history: FeeHistory[];
     }>;
     netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Ekubo CL Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
     /**
      * Calculates realized APY based on TVL per share growth, always valued in USDC.
      * This is a vault-level metric (same for all users) and works for all strategies,
      * regardless of quote asset configuration.
      */
     getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getMaxTVL(): Promise<Web3Number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
     feeBasedAPY(timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
     /**
      * Calculates assets before and now in a given token of TVL per share to observe growth
@@ -1106,15 +1232,122 @@ declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmou
     }>;
     getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
     getSettings: () => Promise<starknet.CallResult>;
+    /**
+     * 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;
     netAPY(): Promise<number>;
     /**
      * 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.
      */
-    getUserRealizedAPY(userAddress: ContractAddr, blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]>;
 }
 declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
 
+interface YoloVaultSettings {
+    startDate: string;
+    expiryDate: string;
+    mainToken: TokenInfo;
+    secondaryToken: TokenInfo;
+    totalEpochs: number;
+    minEpochDurationSeconds: number;
+    spendingLevels: YoloSpendingLevel[];
+    feeBps: number;
+    /** When true, base token is ERC-4626 (e.g. vUSDC); amounts for TVL / user info use `convert_to_assets` into `baseUnderlying`. */
+    isBaseERC4626?: boolean;
+    /** When true, second token is ERC-4626 (e.g. xSTRK); amounts use `convert_to_assets` into `secondUnderlying`. */
+    isSecondERC4626?: boolean;
+    /** Required when `isBaseERC4626` is true (e.g. USDC). */
+    baseUnderlying?: TokenInfo;
+    /** Required when `isSecondERC4626` is true (e.g. STRK / WBTC for xSTRK / xWBTC). */
+    secondUnderlying?: TokenInfo;
+}
+interface YoloSpendingLevel {
+    minPrice?: number;
+    maxPrice?: number;
+    spendPercent: number;
+}
+interface UserYoloInfo {
+    shares: bigint;
+    claimable_second_tokens: bigint;
+    base_token_balance: bigint;
+    base_token_consumed: bigint;
+    base_consumed_last_index: bigint;
+    second_token_last_index: bigint;
+    second_token_balance: bigint;
+}
+interface YoloVaultStatus {
+    current_epoch: bigint;
+    total_epochs: bigint;
+    remaining_base: bigint;
+    total_second_tokens: bigint;
+    global_second_token_index: bigint;
+    cumulative_spend_index: bigint;
+    total_shares: bigint;
+    base_token_assets_per_share: bigint;
+}
+interface YoloSettings {
+    base_token: bigint;
+    second_token: bigint;
+    total_epochs: bigint;
+    min_time_per_epoch: bigint;
+    max_spend_units_per_epoch: bigint;
+    base_token_assets_per_share: bigint;
+    oracle: bigint;
+}
+type YoloErc4626RuntimeConfig = {
+    isBaseERC4626: boolean;
+    isSecondERC4626: boolean;
+    baseUnderlying?: TokenInfo;
+    secondUnderlying?: TokenInfo;
+};
+declare class YoLoVault extends BaseStrategy<DualTokenInfo, SingleActionAmount, DualActionAmount> {
+    readonly address: ContractAddr;
+    readonly metadata: IStrategyMetadata<YoloVaultSettings>;
+    readonly pricer: PricerBase;
+    /** Resolves to a `Contract` built from `provider.getClassAt` at the vault address (no checked-in vault ABI). */
+    readonly contract: Promise<Contract>;
+    readonly primaryToken: TokenInfo;
+    readonly secondaryToken: TokenInfo;
+    readonly erc4626: YoloErc4626RuntimeConfig;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<YoloVaultSettings>);
+    /** Underlying (or base token) used for pricing / swap sell leg when base is ERC-4626. */
+    tokenForPrimaryPricing(): TokenInfo;
+    /** Underlying (or second token) for price ratios when second leg is ERC-4626 (e.g. STRK for xSTRK). */
+    tokenForSecondaryPricing(): TokenInfo;
+    private primaryAmountDecimals;
+    private secondaryAmountDecimals;
+    private convertWrapperSharesToUnderlying;
+    private getNormalizedUserInfo;
+    private resolveWithdrawRequest;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getTVL(): Promise<DualTokenInfo>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    getVaultStatus(): Promise<YoloVaultStatus>;
+    matchInputAmounts(amountInfo: DualActionAmount, user: ContractAddr): Promise<DualActionAmount>;
+    withdrawCall(amountInfo: DualActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    netAPY(): Promise<number | string | NetAPYDetails>;
+    getSwapAmounts(spendUnits: Web3Number): Promise<{
+        grossSpend: Web3Number;
+        netSpend: Web3Number;
+        isReadyForNextSwap: boolean;
+    }>;
+    getSettings: () => Promise<YoloSettings>;
+    getMaxTVL(): Promise<Web3Number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
+}
+declare const YoloVaultStrategies: IStrategyMetadata<YoloVaultSettings>[];
+
 interface LeveledLogMethod {
     (message: string, ...meta: any[]): void;
     (message: any): void;
@@ -1368,6 +1601,24 @@ declare const VesuPools: {
     Re7xSTRK: ContractAddr;
     Re7xBTC: ContractAddr;
     Prime: ContractAddr;
+    Re7STRK: ContractAddr;
+};
+declare const VesuPoolMetadata: {
+    [VesuPools.Genesis.address]: {
+        name: string;
+    };
+    [VesuPools.Re7xSTRK.address]: {
+        name: string;
+    };
+    [VesuPools.Re7xBTC.address]: {
+        name: string;
+    };
+    [VesuPools.Prime.address]: {
+        name: string;
+    };
+    [VesuPools.Re7STRK.address]: {
+        name: string;
+    };
 };
 declare const extensionMap: {
     [key: string]: ContractAddr;
@@ -1410,8 +1661,15 @@ declare class VesuAdapter extends BaseAdapter {
     getModifyPositionCall: (params: VesuModifyPositionCallParams) => ManageCall;
     getMultiplyAdapter: (id: string) => LeafAdapterFn<VesuMultiplyCallParams>;
     getMultiplyCall: (params: VesuMultiplyCallParams) => ManageCall;
-    getVesuModifyDelegationAdapter: (id: string) => LeafAdapterFn<VesuModifyDelegationCallParams>;
-    getVesuModifyDelegationCall: (params: VesuModifyDelegationCallParams) => ManageCall;
+    getVesuModifyDelegationAdapter: (id: string, delegatee: ContractAddr) => LeafAdapterFn<VesuModifyDelegationCallParams>;
+    getVesuModifyDelegationCall: (delegatee: ContractAddr) => (params: VesuModifyDelegationCallParams) => {
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    };
     getDefispringRewardsAdapter: (id: string) => () => AdapterLeafType<VesuDefiSpringRewardsCallParams>;
     getDefiSpringClaimCall: () => GenerateCallFn<VesuDefiSpringRewardsCallParams>;
     formatAmountTypeEnum(amountType: VesuAmountType): CairoCustomEnum;
@@ -1466,6 +1724,11 @@ declare const AVNU_EXCHANGE: ContractAddr;
 declare const VESU_SINGLETON: ContractAddr;
 declare function toBigInt(value: string | number): bigint;
 
+declare enum LSTPriceType {
+    ENDUR_PRICE = "ENDUR_PRICE",
+    AVNU_PRICE = "AVNU_PRICE"
+}
+
 interface UniversalManageCall {
     proofs: string[];
     manageCall: ManageCall;
@@ -1550,6 +1813,7 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
      * Returns the APY as a number.
      */
     getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
     /**
        * Calculates the total TVL of the strategy.
        * @returns Object containing the total amount in token units and USD value
@@ -1559,10 +1823,11 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
         amount: Web3Number;
         usdValue: number;
     }>;
+    getMaxTVL(): Promise<Web3Number>;
     getUnusedBalance(): Promise<SingleTokenInfo>;
-    protected getVesuAUM(adapter: VesuAdapter): Promise<Web3Number>;
+    protected getVesuAUM(adapter: VesuAdapter, _priceType?: LSTPriceType): Promise<Web3Number>;
     getPrevAUM(): Promise<Web3Number>;
-    getAUM(): Promise<{
+    getAUM(unrealizedAUM?: boolean): Promise<{
         net: SingleTokenInfo;
         prevAum: Web3Number;
         splits: {
@@ -1641,10 +1906,12 @@ declare function getContractDetails(settings: UniversalStrategySettings): {
 declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
 
 interface HyperLSTStrategySettings extends UniversalStrategySettings {
-    borrowable_assets: TokenInfo[];
+    borrowable_assets: {
+        token: TokenInfo;
+        poolId: ContractAddr;
+    }[];
     underlyingToken: TokenInfo;
     defaultPoolId: ContractAddr;
-    altSupportedPoolIds: ContractAddr[];
 }
 declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
     private quoteAmountToFetchPrice;
@@ -1679,7 +1946,22 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
         shouldRebalance: boolean;
         manageCall: Call | undefined;
     }>;
-    protected getVesuAUM(adapter: VesuAdapter): Promise<Web3Number>;
+    protected getVesuAUM(adapter: VesuAdapter, priceType?: LSTPriceType): Promise<Web3Number>;
+    getTVLUnrealized(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: {
+            id: string;
+            aum: Web3Number;
+        }[];
+    }>;
+    getUserUnrealizedGains(user: ContractAddr): Promise<{
+        unrealizedGains: Web3Number;
+        userShare: number;
+        tokenInfo: TokenInfo;
+    }>;
+    getMaxTVL(): Promise<Web3Number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
     private _getMinOutputAmountLSTBuy;
     private _getMinOutputAmountLSTSell;
     /**
@@ -1704,6 +1986,7 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
             maxBorrowableAmount: Web3Number;
             borrowableAsset: TokenInfo;
             ltv: number;
+            poolId: ContractAddr;
         }[];
     }>;
     getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number): Promise<Web3Number>;
@@ -1732,6 +2015,7 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
         apy: number;
         weight: number;
     }>;
+    getLSTAvnuRate(): Promise<number>;
     getLSTExchangeRate(): Promise<number>;
     /**
      *
@@ -1762,7 +2046,6 @@ interface FilterOption {
 interface StrategyFilterMetadata {
     assets: FilterOption[];
     protocols: FilterOption[];
-    categories: FilterOption[];
     quickFilters: FilterOption[];
 }
 /**
@@ -1773,7 +2056,8 @@ declare enum StrategyType {
     UNIVERSAL = "universal",
     HYPER_LST = "hyper-lst",
     VESU_REBALANCE = "vesu-rebalance",
-    SENSEI = "sensei"
+    SENSEI = "sensei",
+    YOLO_VAULT = "yolo-vault"
 }
 /**
  * Strategy metadata extracted from IStrategyMetadata
@@ -1784,7 +2068,6 @@ interface StrategyMetadata {
     type: StrategyType;
     assets: string[];
     protocols: string[];
-    category: string;
     tags: string[];
     curator?: {
         name: string;
@@ -1825,10 +2108,12 @@ declare enum FactoryStrategyType {
     EKUBO_CL = "EKUBO_CL",
     HYPER_LST = "HYPER_LST",
     VESU_REBALANCE = "VESU_REBALANCE",
-    SENSEI = "SENSEI"
+    SENSEI = "SENSEI",
+    YOLO_VAULT = "YOLO_VAULT"
 }
 declare function createUniversalStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>): UniversalStrategy<UniversalStrategySettings>;
 declare function createEkuboCLStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>): EkuboCLVault;
+declare function createYoloVaultStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<YoloVaultSettings>): YoLoVault;
 declare function createHyperLSTStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>): UniversalLstMultiplierStrategy;
 declare function createVesuRebalanceStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>): VesuRebalance;
 declare function createSenseiStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>): SenseiVault;
@@ -1839,7 +2124,7 @@ declare function getStrategyTypeFromMetadata(metadata: IStrategyMetadata<any>):
 /**
  * Generic factory function that creates SDK strategy instances based on type
  */
-declare function createStrategy(type: FactoryStrategyType, config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<any>): VesuRebalance | EkuboCLVault | SenseiVault | UniversalStrategy<UniversalStrategySettings>;
+declare function createStrategy(type: FactoryStrategyType, config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<any>): VesuRebalance | EkuboCLVault | SenseiVault | YoLoVault | UniversalStrategy<UniversalStrategySettings>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -1963,6 +2248,16 @@ declare class LSTAPRService {
     static clearCache(): void;
 }
 
+declare class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS: string;
+    readonly contract: Contract;
+    private readonly USDC_ADDRESS;
+    private readonly USDC_DECIMALS;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    private div2Power128;
+    getPrice(tokenAddr: string, blockIdentifier?: BlockIdentifier): Promise<PriceInfo>;
+}
+
 declare class TelegramNotif {
     private subscribers;
     readonly bot: TelegramBot;
@@ -2115,4 +2410,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FactoryStrategyType, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, InstantWithdrawalVault, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionExpectedTime, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type StrategyAlert, type StrategyCapabilities, StrategyCategory, type StrategyFilterMetadata, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VaultType, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, buildStrategyRegistry, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getContractDetails, getDefaultStoreConfig, getFilterMetadata, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };
+export { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, EkuboPricer, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FactoryStrategyType, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type ICurator, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type InputModeFromAction, InstantWithdrawalVault, LSTAPRService, LSTPriceType, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerAvnuApi, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type StrategyAlert, type StrategyApyHistoryUIConfig, type StrategyCapabilities, type StrategyFilterMetadata, type StrategyInputMode, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, UnwrapLabsCurator, type UserPositionCard, type UserPositionCardSubValueColor, type UserPositionCardsInput, type UserYoloInfo, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VaultType, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPoolMetadata, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, YoLoVault, type YoloSettings, type YoloSpendingLevel, type YoloVaultSettings, type YoloVaultStatus, YoloVaultStrategies, ZkLend, assert, buildStrategyRegistry, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, createYoloVaultStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getAllStrategyTags, getContractDetails, getDefaultStoreConfig, getFilterMetadata, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTagDesciption, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };