@strkfarm/sdk 2.0.0-dev.34 → 2.0.0-dev.36

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Call, Contract, Uint256, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import { Uint256, RpcProvider, BlockIdentifier, Call, Contract, Account, CairoCustomEnum, RawArgs } from 'starknet';
 import BigNumber from 'bignumber.js';
 import React, { ReactNode } from 'react';
 import { Quote, AvnuOptions } from '@avnu/avnu-sdk';
@@ -38,6 +38,7 @@ declare class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
 declare class Web3Number extends _Web3Number<Web3Number> {
     static fromWei(weiNumber: string | number, decimals: number): Web3Number;
     static fromNumber(number: number, decimals: number): Web3Number;
+    static fromUint256(uint256Value: Uint256): Web3Number;
 }
 
 /**
@@ -127,6 +128,10 @@ interface IProtocol {
     name: string;
     logo: string;
 }
+interface ICurator {
+    name: string;
+    logo: string;
+}
 declare enum StrategyTag {
     META_VAULT = "Meta Vaults",
     LEVERED = "Maxx",
@@ -137,7 +142,8 @@ declare enum VaultType {
     LOOPING = "Looping",
     META_VAULT = "Meta Vault",
     DELTA_NEUTRAL = "Delta Neutral",
-    AUTOMATED_LP = "Automated LP"
+    AUTOMATED_LP = "Automated LP",
+    TVA = "Troves Value Averaging"
 }
 declare enum AuditStatus {
     AUDITED = "Audited",
@@ -149,7 +155,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",
@@ -162,7 +169,7 @@ interface SourceCodeInfo {
 interface AccessControlInfo {
     type: AccessControlType;
     addresses: ContractAddr[];
-    timeLock: string;
+    timeLock?: string;
 }
 interface SecurityMetadata {
     auditStatus: AuditStatus;
@@ -215,6 +222,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.
@@ -225,6 +236,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";
@@ -241,7 +265,7 @@ interface IStrategyMetadata<T> {
         notARisks: RiskType[];
     };
     apyMethodology?: string;
-    realizedAPYMethodology?: string;
+    realizedApyMethodology?: string;
     additionalInfo: T;
     contractDetails: {
         address: ContractAddr;
@@ -256,10 +280,7 @@ interface IStrategyMetadata<T> {
     }[];
     docs?: string;
     investmentSteps: string[];
-    curator?: {
-        name: string;
-        logo: string;
-    };
+    curator?: ICurator;
     isPreview?: boolean;
     tags?: StrategyTag[];
     security: SecurityMetadata;
@@ -272,6 +293,7 @@ interface IStrategyMetadata<T> {
         info?: React.ReactNode | string;
     };
     settings?: StrategySettings;
+    apyHistoryUIConfig?: StrategyApyHistoryUIConfig;
     actions?: Array<{
         name?: string;
         pool?: {
@@ -291,6 +313,8 @@ interface IStrategyMetadata<T> {
         amount?: string | number;
         isDeposit?: boolean;
     }>;
+    parentId?: string;
+    parentName?: string;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -351,6 +375,7 @@ declare const Protocols: {
     VAULT: IProtocol;
     TROVES: IProtocol;
 };
+declare const UnwrapLabsCurator: ICurator;
 
 interface ILendingMetadata {
     name: string;
@@ -496,6 +521,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;
@@ -504,23 +531,55 @@ 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
@@ -690,7 +749,7 @@ declare class AvnuWrapper {
     getQuotes(fromToken: string, toToken: string, amountWei: string, taker: string, retry?: number, excludeSources?: string[]): Promise<Quote>;
     getSwapInfo(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string, integratorFeeBps: number, integratorFeeRecipient: string, minAmount?: string, options?: AvnuOptions): Promise<SwapInfo>;
     static buildZeroSwap(tokenToSell: ContractAddr, beneficiary: string, tokenToBuy?: ContractAddr): SwapInfo;
-    getSwapCallData(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string): Promise<bigint[][]>;
+    getSwapCallData(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string, minAmount?: Web3Number): Promise<bigint[][]>;
 }
 
 declare class AutoCompounderSTRK {
@@ -1029,6 +1088,8 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * 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
@@ -1241,9 +1302,105 @@ declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmou
      * Not implemented for Sensei Strategy yet.
      */
     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;
@@ -1383,6 +1540,11 @@ declare class HealthFactorMath {
     static getHealthFactor(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, debtAmount: Web3Number, debtPrice: number): number;
     static getMaxDebtAmountOnLooping(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, targetHF: number, debtPrice: number, debtTokenInfo: TokenInfo): Web3Number;
     static getMaxDebtAmount(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, targetHF: number, debtPrice: number, debtTokenInfo: TokenInfo): Web3Number;
+    static calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number, targetHF: number, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, collateralTokenInfo: TokenInfo, debtTokenInfo: TokenInfo) => {
+        deltadebtAmountUnits: null;
+    } | {
+        deltadebtAmountUnits: Web3Number;
+    };
 }
 
 type RequiredFields<T> = {
@@ -1869,6 +2031,7 @@ declare class VesuMultiplyAdapter extends BaseAdapter<VesuDepositParams, VesuWit
     protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
     protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
     maxBorrowableAPY(): Promise<number>;
+    private _computeMax;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     maxWithdraw(): Promise<PositionInfo>;
     protected _getDepositLeaf(): {
@@ -1958,574 +2121,22 @@ declare class VesuModifyPositionAdapter extends BaseAdapter<VesuModifyPositionDe
     getDepositCall(params: VesuModifyPositionDepositParams): Promise<ManageCall[]>;
     getWithdrawCall(params: VesuModifyPositionWithdrawParams): Promise<ManageCall[]>;
     getHealthFactor(): Promise<number>;
-}
-
-/**
- * TypeScript type definitions for Extended Exchange API
- * Based on Python SDK models from x10.perpetual
- */
-declare enum OrderSide {
-    BUY = "BUY",
-    SELL = "SELL"
-}
-declare enum TimeInForce {
-    GTT = "GTT",
-    IOC = "IOC",
-    FOK = "FOK"
-}
-declare enum OrderType {
-    LIMIT = "LIMIT",
-    CONDITIONAL = "CONDITIONAL",
-    MARKET = "MARKET",
-    TPSL = "TPSL"
-}
-declare enum OrderStatus {
-    UNKNOWN = "UNKNOWN",
-    NEW = "NEW",
-    UNTRIGGERED = "UNTRIGGERED",
-    PARTIALLY_FILLED = "PARTIALLY_FILLED",
-    FILLED = "FILLED",
-    CANCELLED = "CANCELLED",
-    EXPIRED = "EXPIRED",
-    REJECTED = "REJECTED"
-}
-declare enum OrderStatusReason {
-    UNKNOWN = "UNKNOWN",
-    NONE = "NONE",
-    UNKNOWN_MARKET = "UNKNOWN_MARKET",
-    DISABLED_MARKET = "DISABLED_MARKET",
-    NOT_ENOUGH_FUNDS = "NOT_ENOUGH_FUNDS",
-    NO_LIQUIDITY = "NO_LIQUIDITY",
-    INVALID_FEE = "INVALID_FEE",
-    INVALID_QTY = "INVALID_QTY",
-    INVALID_PRICE = "INVALID_PRICE",
-    INVALID_VALUE = "INVALID_VALUE",
-    UNKNOWN_ACCOUNT = "UNKNOWN_ACCOUNT",
-    SELF_TRADE_PROTECTION = "SELF_TRADE_PROTECTION",
-    POST_ONLY_FAILED = "POST_ONLY_FAILED",
-    REDUCE_ONLY_FAILED = "REDUCE_ONLY_FAILED",
-    INVALID_EXPIRE_TIME = "INVALID_EXPIRE_TIME",
-    POSITION_TPSL_CONFLICT = "POSITION_TPSL_CONFLICT",
-    INVALID_LEVERAGE = "INVALID_LEVERAGE",
-    PREV_ORDER_NOT_FOUND = "PREV_ORDER_NOT_FOUND",
-    PREV_ORDER_TRIGGERED = "PREV_ORDER_TRIGGERED",
-    TPSL_OTHER_SIDE_FILLED = "TPSL_OTHER_SIDE_FILLED",
-    PREV_ORDER_CONFLICT = "PREV_ORDER_CONFLICT",
-    ORDER_REPLACED = "ORDER_REPLACED",
-    POST_ONLY_MODE = "POST_ONLY_MODE",
-    REDUCE_ONLY_MODE = "REDUCE_ONLY_MODE",
-    TRADING_OFF_MODE = "TRADING_OFF_MODE"
-}
-declare enum PositionSide {
-    LONG = "LONG",
-    SHORT = "SHORT"
-}
-declare enum ExitType {
-    TRADE = "TRADE",
-    LIQUIDATION = "LIQUIDATION",
-    ADL = "ADL"
-}
-declare enum AssetOperationType {
-    DEPOSIT = "DEPOSIT",
-    WITHDRAWAL = "WITHDRAWAL",
-    TRANSFER = "TRANSFER"
-}
-declare enum AssetOperationStatus {
-    CREATED = "CREATED",
-    IN_PROGRESS = "IN_PROGRESS",
-    COMPLETED = "COMPLETED",
-    REJECTED = "REJECTED"
-}
-interface SettlementSignature {
-    r: string;
-    s: string;
-}
-interface StarkSettlement {
-    signature: SettlementSignature;
-    stark_key: string;
-    collateral_position: string;
-}
-interface StarkDebuggingOrderAmounts {
-    collateral_amount: string;
-    fee_amount: string;
-    synthetic_amount: string;
-}
-interface PlacedOrder {
-    id: number;
-    external_id: string;
-}
-interface OpenOrder {
-    id: number;
-    account_id: number;
-    external_id: string;
-    market: string;
-    type: OrderType;
-    side: OrderSide;
-    status: OrderStatus;
-    status_reason?: OrderStatusReason;
-    price: string;
-    average_price?: string;
-    qty: string;
-    filled_qty?: string;
-    reduce_only: boolean;
-    post_only: boolean;
-    payed_fee?: string;
-    created_time: number;
-    updated_time: number;
-    expiry_time?: number;
-}
-interface Position {
-    id: number;
-    accountId: number;
-    market: string;
-    side: PositionSide;
-    leverage: string;
-    size: string;
-    value: string;
-    openPrice: string;
-    markPrice: string;
-    liquidationPrice?: string;
-    unrealisedPnl: string;
-    realisedPnl: string;
-    tpPrice?: string;
-    slPrice?: string;
-    adl?: number;
-    createdAt: number;
-    updatedAt: number;
-}
-interface PositionHistory {
-    id: number;
-    account_id: number;
-    market: string;
-    side: PositionSide;
-    leverage: string;
-    size: string;
-    open_price: string;
-    exit_type?: ExitType;
-    exit_price?: string;
-    realised_pnl: string;
-    created_time: number;
-    closed_time?: number;
-}
-interface Balance {
-    collateral_name: string;
-    balance: string;
-    equity: string;
-    availableForTrade: string;
-    availableForWithdrawal: string;
-    unrealisedPnl: string;
-    initialMargin: string;
-    marginRatio: string;
-    updatedTime: number;
-}
-interface RiskFactorConfig {
-    upper_bound: string;
-    risk_factor: string;
-}
-interface MarketStats {
-    daily_volume: string;
-    daily_volume_base: string;
-    daily_price_change: string;
-    daily_low: string;
-    daily_high: string;
-    last_price: string;
-    ask_price: string;
-    bid_price: string;
-    mark_price: string;
-    index_price: string;
-    funding_rate: string;
-    next_funding_rate: number;
-    open_interest: string;
-    open_interest_base: string;
-}
-interface TradingConfig {
-    min_order_size: string;
-    min_order_size_change: string;
-    min_price_change: string;
-    max_market_order_value: string;
-    max_limit_order_value: string;
-    max_position_value: string;
-    max_leverage: string;
-    max_num_orders: number;
-    limit_price_cap: string;
-    limit_price_floor: string;
-    risk_factor_config: RiskFactorConfig[];
-}
-interface L2Config {
-    type: string;
-    collateral_id: string;
-    collateral_resolution: number;
-    synthetic_id: string;
-    synthetic_resolution: number;
-}
-interface Market {
-    name: string;
-    asset_name: string;
-    asset_precision: number;
-    collateral_asset_name: string;
-    collateral_asset_precision: number;
-    active: boolean;
-    market_stats: MarketStats;
-    trading_config: TradingConfig;
-    l2_config: L2Config;
-}
-interface AssetOperation {
-    id: string;
-    type: AssetOperationType;
-    status: AssetOperationStatus;
-    amount: string;
-    asset: string;
-    created_time: number;
-    updated_time: number;
-    description?: string;
-    transactionHash?: string;
-}
-interface CreateOrderRequest {
-    market_name: string;
-    amount: string;
-    price: string;
-    side: OrderSide;
-    post_only?: boolean;
-    reduce_only?: boolean;
-    previous_order_id?: number;
-    external_id?: string;
-    time_in_force?: TimeInForce;
-}
-interface WithdrawRequest {
-    amount: string;
-    asset?: string;
-}
-interface SignedWithdrawRequest {
-    recipient: string;
-    position_id: number;
-    amount: number;
-    expiration: number;
-    salt: number;
-}
-interface CancelOrderRequest {
-    order_id: number;
-}
-interface ApiResponse<T> {
-    success: boolean;
-    message: string;
-    data: T;
-}
-interface ExtendedApiResponse<T> {
-    status: 'OK' | 'ERROR';
-    message: string;
-    data: T;
-}
-interface ExtendedWrapperConfig {
-    readUrl: string;
-    writeUrl: string;
-    apiKey?: string;
-    timeout?: number;
-    retries?: number;
-}
-interface UpdateLeverageRequest {
-    leverage: string;
-    market: string;
-}
-interface FundingRate {
-    m: string;
-    f: string;
-    t: number;
-}
-interface FundingPayment {
-    id: number;
-    accountId?: number;
-    account_id?: number;
-    market: string;
-    positionId?: number;
-    position_id?: number;
-    side: PositionSide;
-    size: string;
-    value: string;
-    markPrice?: string;
-    mark_price?: string;
-    fundingFee?: string;
-    funding_fee?: string;
-    fundingRate?: string;
-    funding_rate?: string;
-    paidTime?: number;
-    paid_time?: number;
-}
-
-/**
- * ExtendedWrapper - TypeScript wrapper for Extended Exchange API
- * Provides a clean interface to interact with the Extended Exchange trading API
- */
-
-declare class ExtendedWrapper {
-    private readUrl;
-    private writeUrl;
-    private apiKey?;
-    private timeout;
-    private retries;
-    /** Per-market rules from GET /markets (tradingConfig); retained for process lifetime (no TTL). */
-    private marketTradingRulesCache;
-    private marketTradingRulesInflight;
-    constructor(config: ExtendedWrapperConfig);
-    /**
-     * Make HTTP request with retry logic and error handling
-     */
-    private makeRequest;
-    private resolveTradingRules;
-    /**
-     * Create a new order on Extended Exchange
-     */
-    createOrder(request: CreateOrderRequest): Promise<ExtendedApiResponse<PlacedOrder>>;
-    /**
-     * Get all markets
-     */
-    getMarkets(marketNames?: string): Promise<ExtendedApiResponse<Market[]>>;
-    /**
-     *
-     * @param orderId - The ID of the order to get
-     * @returns The order
-     */
-    getOrderByOrderId(orderId: string): Promise<ExtendedApiResponse<OpenOrder>>;
-    /**
-     * Get market statistics for a specific market
-     */
-    getMarketStatistics(marketName: string): Promise<ExtendedApiResponse<MarketStats>>;
-    /**
-     * Get current trading positions
-     */
-    getPositions(marketNames?: string): Promise<ExtendedApiResponse<Position[]>>;
-    /**
-     * Get account balance and holdings
-     */
-    getHoldings(): Promise<ExtendedApiResponse<Balance>>;
-    /**
-     * Initiate a withdrawal from Extended Exchange
-     * Returns data as number | string to preserve precision for large integers
-     */
-    withdraw(request: WithdrawRequest): Promise<ExtendedApiResponse<number | string>>;
-    /**
-     * Create and sign a withdrawal request hash
-     */
-    signWithdrawalRequest(request: SignedWithdrawRequest): Promise<ExtendedApiResponse<{
-        withdraw_request_hash: string;
-        signature: {
-            r: string;
-            s: string;
-        };
-    }>>;
-    /**
-     * Cancel an existing order
-     */
-    cancelOrder(request: CancelOrderRequest): Promise<ExtendedApiResponse<{}>>;
-    /**
-     * Get all open orders
-     */
-    getOpenOrders(marketName?: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
-    /**
-     * Update leverage on the market
-     * @param request
-     * @returns
-     */
-    updateLeverage(request: UpdateLeverageRequest): Promise<ExtendedApiResponse<{}>>;
-    /**
-     * Get asset operations with optional filtering
-     */
-    getAssetOperations(options?: {
-        id?: number;
-        operationsType?: AssetOperationType[];
-        operationsStatus?: AssetOperationStatus[];
-        startTime?: number;
-        endTime?: number;
-        cursor?: number;
-        limit?: number;
-    }): Promise<ExtendedApiResponse<AssetOperation[]>>;
-    /**
-     * Health check endpoint
-     */
-    healthCheck(): Promise<ExtendedApiResponse<MarketStats>>;
-    /**
-     * Convenience method to create a buy order
-     */
-    createBuyOrder(marketName: string, amount: string, price: string, options?: {
-        post_only?: boolean;
-        reduce_only?: boolean;
-        previous_order_id?: number;
-        external_id?: string;
-        time_in_force?: TimeInForce;
-    }): Promise<ExtendedApiResponse<PlacedOrder>>;
-    /**
-     * Get order by ID
-     * @param orderId - The ID of the order to get
-     * @returns The order
-     */
-    getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>>;
-    /**
-     * Convenience method to create a sell order
-     */
-    createSellOrder(marketName: string, amount: string, price: string, options?: {
-        post_only?: boolean;
-        reduce_only?: boolean;
-        previous_order_id?: number;
-        external_id?: string;
-        time_in_force?: TimeInForce;
-    }): Promise<ExtendedApiResponse<PlacedOrder>>;
-    /**
-     * Get positions for a specific market
-     */
-    getPositionsForMarket(marketName: string): Promise<ExtendedApiResponse<Position[]>>;
     /**
-     * Get open orders for a specific market
+     * Simulates a deposit of `depositAmount` collateral and returns how much
+     * debt (STRK) would be incrementally borrowed to reach the target LTV.
+     * Used upstream to size the AVNU swap call in the same transaction batch.
      */
-    getOpenOrdersForMarket(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
+    getExpectedDepositDebtDelta(depositAmount: Web3Number): Promise<Web3Number>;
     /**
-     * Cancel order by ID (convenience method)
+     * Simulates a withdrawal of `withdrawAmount` collateral and returns the
+     * incremental debt delta needed to keep the target health factor.
+     * Positive means borrow, negative means repay.
      */
-    cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>>;
-    /**
-     * Get order history for a specific market
-     * @param marketName - The name of the market to get order history for
-     * @returns The order history for the specified market
-     */
-    getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
-    /**
-     * Withdraw USDC (convenience method)
-     * Returns data as number | string to preserve precision for large integers
-     */
-    withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number | string>>;
-    /**
-     * Get funding rates for a specific market
-     * @param marketName - The name of the market to get funding rates for
-     * @returns The funding rates for the specified market
-     */
-    getFundingRates(marketName: string, side: string, startTime?: number, endTime?: number): Promise<ExtendedApiResponse<FundingRate[]>>;
-    /**
-     * Get funding payments for a specific market.
-     */
-    getUserFundingPayments(marketName: string, side: string, startTime: number, limit?: number, cursor?: number): Promise<ExtendedApiResponse<FundingPayment[]>>;
-}
-
-interface AvnuAdapterConfig extends BaseAdapterConfig {
-    baseUrl: string;
-    avnuContract: ContractAddr;
-    slippage: number;
-    minimumExtendedPriceDifferenceForSwapOpen: number;
-    maximumExtendedPriceDifferenceForSwapClosing: number;
-}
-declare class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: AvnuAdapterConfig;
-    protected avnuWrapper: AvnuWrapper;
-    lastSwapPriceInfo: SwapPriceInfo | null;
-    private _depositApproveProofReadableId;
-    private _depositSwapProofReadableId;
-    private _withdrawApproveProofReadableId;
-    private _withdrawSwapProofReadableId;
-    private buildSwapLeafConfigs;
-    private buildSwapCalls;
-    constructor(config: AvnuAdapterConfig);
-    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
-    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
-    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
-    maxWithdraw(): Promise<PositionInfo>;
-    protected _getDepositLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    protected _getWithdrawLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    protected _getLegacySwapLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    getSwapCallData(quote: Quote): Promise<bigint[][]>;
-    getHealthFactor(): Promise<number>;
-    fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
-}
-
-interface ExtendedAdapterConfig extends BaseAdapterConfig {
-    vaultIdExtended: number;
-    extendedContract: ContractAddr;
-    extendedBackendReadUrl: string;
-    extendedBackendWriteUrl: string;
-    extendedTimeout: number;
-    extendedRetries: number;
-    extendedBaseUrl: string;
-    extendedMarketName: string;
-    extendedPrecision: number;
-    avnuAdapter: AvnuAdapter;
-    retryDelayForOrderStatus: number;
-    minimumExtendedMovementAmount: number;
-}
-declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: ExtendedAdapterConfig;
-    readonly client: ExtendedWrapper;
-    readonly usdcToken: TokenInfo;
-    readonly retryDelayForOrderStatus: number;
-    readonly minimumExtendedMovementAmount: number;
-    constructor(config: ExtendedAdapterConfig);
-    private _depositApproveProofReadableId;
-    private _depositCallProofReadableId;
-    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
-    getFundingRates(side: string, startTime?: number, endTime?: number): Promise<{
-        success: boolean;
-        data: FundingRate[];
-    }>;
-    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
-    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
-    maxWithdraw(): Promise<PositionInfo>;
-    protected _getDepositLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    protected _getWithdrawLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    withdrawFromExtended(amount: Web3Number): Promise<{
-        status: boolean;
-        receivedTxnHash: boolean;
-    }>;
-    getHealthFactor(): Promise<number>;
-    getExtendedDepositAmount(): Promise<Balance | undefined>;
-    setLeverage(leverage: string, marketName: string): Promise<boolean>;
-    getAllOpenPositions(): Promise<Position[] | null>;
-    getOrderStatus(orderId: string, marketName: string): Promise<OpenOrder | null>;
-    fetchOrderBookFromExtended(): Promise<{
-        status: boolean;
-        bid: Web3Number;
-        ask: Web3Number;
-    }>;
-    createOrder(leverage: string, btcAmount: number, side: OrderSide, attempt?: number, maxAttempts?: number): Promise<{
-        position_id: string;
-        btc_exposure: string;
-    } | null>;
-    createExtendedPositon(client: ExtendedWrapper, marketName: string, amount: string, price: string, side: OrderSide): Promise<{
-        position_id: string;
-    } | null>;
-    getDepositOrWithdrawalStatus(orderId: number | string, // for deposits, send txn hash as string
-    operationsType: AssetOperationType): Promise<boolean>;
+    getExpectedWithdrawDebtDelta(withdrawAmount: Web3Number): Promise<Web3Number>;
 }
 
 declare const SIMPLE_SANITIZER: ContractAddr;
+declare const SVK_SIMPLE_SANITIZER: ContractAddr;
 declare const EXTENDED_SANITIZER: ContractAddr;
 declare const AVNU_LEGACY_SANITIZER: ContractAddr;
 declare const SIMPLE_SANITIZER_V2: ContractAddr;
@@ -2585,6 +2196,62 @@ declare class TokenTransferAdapter extends BaseAdapter<DepositParams, WithdrawPa
     getHealthFactor(): Promise<number>;
 }
 
+interface AvnuDepositParams extends DepositParams {
+    minAmount?: Web3Number;
+}
+interface AvnuWithdrawParams extends WithdrawParams {
+    minAmount?: Web3Number;
+}
+interface AvnuAdapterConfig extends BaseAdapterConfig {
+    baseUrl: string;
+    avnuContract: ContractAddr;
+    slippage: number;
+    minimumExtendedPriceDifferenceForSwapOpen: number;
+    maximumExtendedPriceDifferenceForSwapClosing: number;
+}
+declare class AvnuAdapter extends BaseAdapter<AvnuDepositParams, AvnuWithdrawParams> {
+    readonly config: AvnuAdapterConfig;
+    protected avnuWrapper: AvnuWrapper;
+    lastSwapPriceInfo: SwapPriceInfo | null;
+    private _depositApproveProofReadableId;
+    private _depositSwapProofReadableId;
+    private _withdrawApproveProofReadableId;
+    private _withdrawSwapProofReadableId;
+    private buildSwapLeafConfigs;
+    private buildSwapCalls;
+    constructor(config: AvnuAdapterConfig);
+    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
+    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    maxWithdraw(): Promise<PositionInfo>;
+    protected _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getLegacySwapLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getDepositCall(params: AvnuDepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: AvnuWithdrawParams): Promise<ManageCall[]>;
+    getSwapCallData(quote: Quote): Promise<bigint[][]>;
+    getHealthFactor(): Promise<number>;
+    fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
+}
+
 /** Public Troves strategies feed (APY + metadata). Override in config for tests. */
 declare const DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
 interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
@@ -2604,6 +2271,11 @@ interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
     positionOwner?: ContractAddr;
     /** Optional APY endpoint (defaults to {@link DEFAULT_TROVES_STRATEGIES_API}). */
     trovesStrategiesApiUrl?: string;
+    /**
+     * Optional redeem request NFT contract address. When provided, pending assets are calculated
+     * using `getPendingAssetsFromOwnerNFTMethod` instead of `due_assets_from_owner`.
+     */
+    redeemRequestNFT?: ContractAddr;
 }
 /**
  * Universal adapter for **Starknet Vault Kit (SVK)** style Troves strategies:
@@ -2630,6 +2302,17 @@ declare class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams
     private _withdrawCallProofReadableId;
     protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
     protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
+    getPendingAssetsFromOwner(owner?: ContractAddr, decimals?: number): Promise<Web3Number>;
+    /**
+     * Get pending assets from owner by scanning redeem request NFTs.
+     * This method iterates backwards through NFT IDs to find all pending redemptions for a specific owner.
+     *
+     * @param redeemRequestNFT - The redeem request NFT contract address
+     * @param owner - The owner address to check for pending redemptions (defaults to positionOwner)
+     * @param decimals - Token decimals for conversion (defaults to baseToken decimals)
+     * @returns Total pending assets from all NFTs owned by the specified address
+     */
+    getPendingAssetsFromOwnerNFTMethod(redeemRequestNFT: ContractAddr, owner?: ContractAddr, decimals?: number): Promise<Web3Number>;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     maxWithdraw(): Promise<PositionInfo>;
     protected _getDepositLeaf(): {
@@ -2658,186 +2341,6 @@ declare enum LSTPriceType {
     AVNU_PRICE = "AVNU_PRICE"
 }
 
-interface UniversalManageCall {
-    proofs: string[];
-    manageCall: ManageCall;
-    step: UNIVERSAL_MANAGE_IDS;
-}
-interface UniversalStrategySettings {
-    vaultAddress: ContractAddr;
-    manager: ContractAddr;
-    vaultAllocator: ContractAddr;
-    redeemRequestNFT: ContractAddr;
-    aumOracle: ContractAddr;
-    redemptionRouter?: ContractAddr;
-    leafAdapters: LeafAdapterFn<any>[];
-    adapters: {
-        id: string;
-        adapter: BaseAdapter<DepositParams, WithdrawParams>;
-    }[];
-    targetHealthFactor: number;
-    minHealthFactor: number;
-}
-declare enum AUMTypes {
-    FINALISED = "finalised",
-    DEFISPRING = "defispring"
-}
-declare enum PositionTypeAvnuExtended {
-    OPEN = "open",
-    CLOSE = "close"
-}
-declare class UniversalStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
-    /** Contract address of the strategy */
-    readonly address: ContractAddr;
-    /** Pricer instance for token price calculations */
-    readonly pricer: PricerBase;
-    /** Metadata containing strategy information */
-    readonly metadata: IStrategyMetadata<S>;
-    /** Contract instance for interacting with the strategy */
-    readonly contract: Contract;
-    readonly managerContract: Contract;
-    merkleTree: StandardMerkleTree | undefined;
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
-    getMerkleTree(): StandardMerkleTree;
-    getMerkleRoot(): string;
-    getProofs<T>(id: string): {
-        proofs: string[];
-        callConstructor: GenerateCallFn<T>;
-    };
-    getAdapter(id: string): BaseAdapter<any, any>;
-    asset(): TokenInfo;
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }>;
-    getVesuAPYs(): Promise<{
-        baseAPYs: number[];
-        rewardAPYs: number[];
-        positions: VaultPosition[];
-    }>;
-    /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
-     */
-    netAPY(): Promise<{
-        net: number;
-        splits: {
-            apy: number;
-            id: string;
-        }[];
-    }>;
-    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number): Promise<{
-        net: number;
-        splits: {
-            apy: number;
-            id: string;
-        }[];
-    }>;
-    protected getUnusedBalanceAPY(): Promise<{
-        apy: number;
-        weight: number;
-    }>;
-    private computeAPY;
-    /**
-     * Calculates user realized APY based on trueSharesBasedAPY method.
-     * Returns the APY as a number.
-     */
-    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
-    /**
-       * Calculates the total TVL of the strategy.
-       * @returns Object containing the total amount in token units and USD value
-    */
-    getTVL(): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }>;
-    getUnusedBalance(): Promise<SingleTokenInfo>;
-    protected getVesuAUM(adapter: VesuAdapter, _priceType?: LSTPriceType): Promise<Web3Number>;
-    getPrevAUM(): Promise<Web3Number>;
-    getAUM(unrealizedAUM?: boolean): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: {
-            id: string;
-            aum: Web3Number;
-        }[];
-    }>;
-    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
-    getVesuAdapters(): VesuAdapter[];
-    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
-    getManageCall(proofIds: string[], manageCalls: ManageCall[]): Call;
-    getVesuModifyPositionCalls(params: {
-        isLeg1: boolean;
-        isDeposit: boolean;
-        depositAmount: Web3Number;
-        debtAmount: Web3Number;
-    }): UniversalManageCall[];
-    getTag(): string;
-    /**
-     * Gets LST APR for the strategy's underlying asset from Endur API
-     * @returns Promise<number> The LST APR (not divided by 1e18)
-     */
-    getLSTAPR(address: ContractAddr): Promise<number>;
-    getVesuHealthFactors(blockNumber?: BlockIdentifier): Promise<number[]>;
-    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
-    private getNewHealthFactor;
-    /**
-     *
-     * @param vesuAdapter
-     * @param currentHf
-     * @param isDeposit if true, attempt by adding collateral, else by repaying
-     * @returns
-     */
-    private getLegRebalanceAmount;
-    getVesuModifyPositionCall(params: {
-        isDeposit: boolean;
-        leg1DepositAmount: Web3Number;
-    }): Promise<Call>;
-    getBringLiquidityCall(params: {
-        amount: Web3Number;
-    }): Promise<Call>;
-    getPendingRewards(): Promise<HarvestInfo[]>;
-    getHarvestCall(): Promise<{
-        call: Call;
-        reward: Web3Number;
-        tokenInfo: TokenInfo;
-    }>;
-    getRebalanceCall(params: {
-        isLeg1toLeg2: boolean;
-        amount: Web3Number;
-    }): Promise<Call>;
-}
-declare enum UNIVERSAL_MANAGE_IDS {
-    FLASH_LOAN = "flash_loan_init",
-    VESU_LEG1 = "vesu_leg1",
-    VESU_LEG2 = "vesu_leg2",
-    APPROVE_TOKEN1 = "approve_token1",
-    APPROVE_TOKEN2 = "approve_token2",
-    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
-    BRING_LIQUIDITY = "bring_liquidity",
-    DEFISPRING_REWARDS = "defispring_rewards",
-    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
-    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
-}
-declare enum UNIVERSAL_ADAPTERS {
-    COMMON = "common_adapter",
-    VESU_LEG1 = "vesu_leg1_adapter",
-    VESU_LEG2 = "vesu_leg2_adapter"
-}
-declare function getContractDetails(settings: UniversalStrategySettings & {
-    aumOracle?: ContractAddr;
-}): {
-    address: ContractAddr;
-    name: string;
-}[];
-declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
-
 /**
  * Base class for all SVK (Starknet Vault Kit) strategies.
  * Contains common functions that are shared across all SVK strategies.
@@ -2873,7 +2376,7 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
       */
     protected buildManageCallFromAdapter(adapter: {
         getProofs: (isDeposit: boolean, tree: any) => any;
-    }, isDeposit: boolean, amount: Web3Number): Promise<Call>;
+    }, isDeposit: boolean, amount: Web3Number, additionalParams?: Record<string, any>): Promise<Call>;
     /**
      * Bridges liquidity from the vault allocator back to the vault.
      * Note: This function is common for any SVK strategy.
@@ -2929,42 +2432,67 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
             id: string;
         }[];
     }>;
+    getTVL(): Promise<SingleTokenInfo>;
     getPrevAUM(): Promise<Web3Number>;
     maxDepositables(): Promise<PositionInfo[]>;
     maxWithdrawables(): Promise<PositionInfo[]>;
 }
 
-interface HyperLSTStrategySettings extends UniversalStrategySettings {
-    borrowable_assets: TokenInfo[];
-    underlyingToken: TokenInfo;
-    quoteAmountToFetchPrice: Web3Number;
+interface UniversalManageCall {
+    proofs: string[];
+    manageCall: ManageCall;
+    step: UNIVERSAL_MANAGE_IDS;
+}
+interface UniversalStrategySettings {
+    vaultAddress: ContractAddr;
+    manager: ContractAddr;
+    vaultAllocator: ContractAddr;
+    redeemRequestNFT: ContractAddr;
+    aumOracle: ContractAddr;
+    redemptionRouter?: ContractAddr;
+    leafAdapters: LeafAdapterFn<any>[];
+    adapters: {
+        id: string;
+        adapter: BaseAdapter<DepositParams, WithdrawParams>;
+    }[];
     targetHealthFactor: number;
     minHealthFactor: number;
-    aumOracle: ContractAddr;
 }
-declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
-    private quoteAmountToFetchPrice;
+declare enum AUMTypes {
+    FINALISED = "finalised",
+    DEFISPRING = "defispring",
+    BTCFI = "btcfi"
+}
+declare enum PositionTypeAvnuExtended {
+    OPEN = "open",
+    CLOSE = "close"
+}
+declare class UniversalStrategy<S extends UniversalStrategySettings> extends SVKStrategy<S> {
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
-    getTag(): string;
-    getVesuSameTokenAdapter(): VesuMultiplyAdapter;
-    getVesuAdapters(): VesuMultiplyAdapter[];
-    getRewardsAUM(_prevAum: Web3Number): Promise<Web3Number>;
-    getLSTDexPrice(): Promise<number>;
-    getLSTAvnuRate(): Promise<number>;
-    getLSTExchangeRate(): Promise<number>;
-    private _getMinOutputAmountLSTBuy;
-    private _getMinOutputAmountLSTSell;
+    getMerkleTree(): StandardMerkleTree;
+    getMerkleRoot(): string;
+    getProofs<T>(id: string): {
+        proofs: string[];
+        callConstructor: GenerateCallFn<T>;
+    };
+    getAdapter(id: string): BaseAdapter<any, any>;
+    asset(): TokenInfo;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
+    }>;
     /**
-     * Uses vesu's multiple call to create leverage on LST
-     * Deposit amount is in LST
-     * @param params
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
      */
-    getFundManagementCall(params: {
-        isDeposit: boolean;
-        leg1DepositAmount: Web3Number;
-    }): Promise<Call[] | null>;
-    getLSTUnderlyingTokenInfo(): TokenInfo;
-    getLSTAPR(_address: ContractAddr): Promise<number>;
     netAPY(): Promise<{
         net: number;
         splits: {
@@ -2972,1461 +2500,314 @@ declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
             id: string;
         }[];
     }>;
-    maxNewDeposits(params?: {
-        isAPYComputation: boolean;
-    }): Promise<number>;
+    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
     protected getUnusedBalanceAPY(): Promise<{
         apy: number;
         weight: number;
     }>;
+    private computeAPY;
+    /**
+     * Calculates user realized APY based on trueSharesBasedAPY method.
+     * 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
+    */
+    getTVL(): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
+    getUnusedBalance(): Promise<SingleTokenInfo>;
+    protected getVesuAUM(adapter: VesuAdapter, _priceType?: LSTPriceType): Promise<Web3Number>;
+    getPrevAUM(): Promise<Web3Number>;
     getAUM(unrealizedAUM?: boolean): Promise<{
         net: SingleTokenInfo;
         prevAum: Web3Number;
-        splits: PositionInfo[];
+        splits: {
+            id: string;
+            aum: Web3Number;
+        }[];
     }>;
-    getTVLUnrealized(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
-    }>;
-    getUserUnrealizedGains(user: ContractAddr): Promise<{
-        unrealizedGains: Web3Number;
-        userShare: number;
-        tokenInfo: TokenInfo;
-    }>;
-}
-declare const AUDIT_URL = "https://docs.troves.fi/p/security#starknet-vault-kit";
-declare function getFAQs(lstSymbol: string, underlyingSymbol: string, isLST: boolean): FAQ[];
-declare const _riskFactor: RiskFactor[];
-declare function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string): string[];
-declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
-
-/**
- * Snapshot of a single Vesu pool's position: collateral, debt, and their prices.
- */
-interface VesuPoolState {
-    poolId: ContractAddr;
-    collateralToken: TokenInfo;
-    debtToken: TokenInfo;
-    collateralAmount: Web3Number;
-    collateralUsdValue: number;
-    debtAmount: Web3Number;
-    debtUsdValue: number;
-    collateralPrice: number;
-    debtPrice: number;
-}
-/**
- * Snapshot of a single Extended exchange open position.
- */
-interface ExtendedPositionState {
-    instrument: string;
-    side: string;
-    size: Web3Number;
-    valueUsd: Web3Number;
-    leverage: string;
-}
-/**
- * Snapshot of the Extended exchange account-level balance.
- */
-interface ExtendedBalanceState {
-    equity: Web3Number;
-    availableForTrade: Web3Number;
-    availableForWithdrawal: Web3Number;
-    unrealisedPnl: Web3Number;
-    balance: Web3Number;
-    /**
-     * Funds in transit to/from Extended.
-     * Positive = deposit in transit (funds left wallet, not yet credited on Extended).
-     * Negative = withdrawal in transit (funds left Extended, not yet received in wallet).
-     */
-    pendingDeposit: Web3Number;
-}
-/**
- * Generic token balance with USD valuation.
- */
-interface TokenBalance {
-    token: TokenInfo;
-    amount: Web3Number;
-    usdValue: number;
-}
-/**
- * Per-position exposure change on the Extended exchange.
- * Positive delta = increase position size, negative = reduce.
- */
-interface ExtendedPositionDelta {
-    instrument: string;
-    delta: Web3Number;
-}
-/**
- * Per-pool position change on Vesu.
- * debtDelta: positive = borrow more, negative = repay.
- * collateralDelta: positive = add collateral, negative = remove.
- */
-interface VesuPoolDelta {
-    poolId: ContractAddr;
-    collateralToken: TokenInfo;
-    debtToken: TokenInfo;
-    debtDelta: Web3Number;
-    collateralDelta: Web3Number;
-    collateralPrice: number;
-    debtPrice: number;
-}
-/**
- * Enumerates all possible fund-routing paths used during execution.
- */
-declare enum RouteType {
-    /** Deposit USDC from operator wallet directly to Extended exchange */
-    WALLET_TO_EXTENDED = "WALLET_TO_EXTENDED",
-    /** USDC from vault allocator → deposit to Extended (via manager) */
-    VA_TO_EXTENDED = "VA_TO_EXTENDED",
-    /** Withdraw from Extended exchange → operator wallet */
-    EXTENDED_TO_WALLET = "EXTENDED_TO_WALLET",
-    /** Swap USDC → BTC to deposit to Vesu */
-    AVNU_DEPOSIT_SWAP = "AVNU_DEPOSIT_SWAP",
-    /** Increase leverage on Vesu i.e. deposit on vesu, borrow, in one go to create lever */
-    VESU_MULTIPLY_INCREASE_LEVER = "VESU_MULTIPLY_INCREASE_LEVER",
-    /** Decrease leverage on Vesu i.e. withdraw from vesu, repay, in one go to reduce leverage */
-    VESU_MULTIPLY_DECREASE_LEVER = "VESU_MULTIPLY_DECREASE_LEVER",
-    /** Swap BTC → USDC to withdraw from Vesu */
-    AVNU_WITHDRAW_SWAP = "AVNU_WITHDRAW_SWAP",
-    /** Borrow additional USDC from Vesu (when wallet + VA insufficient for Extended) */
-    VESU_BORROW = "VESU_BORROW",
-    /** Repay USDC debt to Vesu (debtDelta < 0) */
-    VESU_REPAY = "VESU_REPAY",
-    /** Transfer USDC from operator wallet to vault allocator */
-    WALLET_TO_VA = "WALLET_TO_VA",
-    /** Realize PnL on Extended exchange */
-    REALISE_PNL = "REALISE_PNL",
-    /** Increase leverage on Extended exchange i.e. deposit on extended, in one go to create lever */
-    EXTENDED_INCREASE_LEVER = "EXTENDED_INCREASE_LEVER",
-    /** Decrease leverage on Extended exchange i.e. withdraw from extended, in one go to reduce leverage */
-    EXTENDED_DECREASE_LEVER = "EXTENDED_DECREASE_LEVER",
-    /** Increase leverage on Extended exchange to max leverage (e.g. 4x from 3x) */
-    CRISIS_INCREASE_EXTENDED_MAX_LEVERAGE = "CRISIS_INCREASE_EXTENDER_MAX_LEVERAGE",
-    /** Undo max leverage on Extended exchange to reduce leverage (e.g. 4x to 3x) */
-    CRISIS_UNDO_EXTENDED_MAX_LEVERAGE = "CRISIS_UNDO_EXTENDED_MAX_LEVERAGE",
-    /** Borrow beyyond target HF (e.g. 1.2 from 1.4) */
-    CRISIS_BORROW_BEYOND_TARGET_HF = "CRISIS_BORROW_BEYOND_TARGET_HF",
-    /** Bring liquidity from vault allocator to vault contract (for user withdrawals) */
-    BRING_LIQUIDITY = "BRING_LIQUIDITY",
-    RETURN_TO_WAIT = "RETURN_TO_WAIT"
-}
-/** Common fields shared by every route variant */
-interface RouteBase {
-    /** Execution order — lower values execute first */
-    priority: number;
-}
-/** Simple fund-transfer routes: WALLET_TO_EXTENDED, VA_TO_EXTENDED, EXTENDED_TO_WALLET, WALLET_TO_VA */
-interface TransferRoute extends RouteBase {
-    type: RouteType.WALLET_TO_EXTENDED | RouteType.VA_TO_EXTENDED | RouteType.EXTENDED_TO_WALLET | RouteType.WALLET_TO_VA;
-    /** Amount to transfer */
-    amount: Web3Number;
-}
-/** AVNU swap routes: AVNU_DEPOSIT_SWAP (USDC→BTC), AVNU_WITHDRAW_SWAP (BTC→USDC) */
-interface SwapRoute extends RouteBase {
-    type: RouteType.AVNU_DEPOSIT_SWAP | RouteType.AVNU_WITHDRAW_SWAP;
-    /** Source token symbol */
-    fromToken: string;
-    /** Source amount */
-    fromAmount: Web3Number;
-    /** Destination token symbol */
-    toToken: string;
-    /** Exact output amount (if known; otherwise undefined means best-effort) */
-    toAmount?: Web3Number;
-}
-/** Vesu multiply lever routes: deposit+borrow or withdraw+repay in one go */
-interface VesuMultiplyRoute extends RouteBase {
-    type: RouteType.VESU_MULTIPLY_INCREASE_LEVER | RouteType.VESU_MULTIPLY_DECREASE_LEVER;
-    /** Pool to interact with */
-    poolId: ContractAddr;
-    /** Collateral token info */
-    collateralToken: TokenInfo;
-    /** Collateral amount delta (positive = deposit, negative = withdraw) */
-    marginAmount: Web3Number;
-    swappedCollateralAmount: Web3Number;
-    /** Debt token info */
-    debtToken: TokenInfo;
-    /** Debt amount delta (positive = borrow, negative = repay) */
-    debtAmount: Web3Number;
-}
-/** Vesu single-side borrow / repay routes */
-interface VesuDebtRoute extends RouteBase {
-    type: RouteType.VESU_BORROW | RouteType.VESU_REPAY;
-    /** Pool to interact with */
-    poolId: ContractAddr;
-    /** Amount to borrow (positive) or repay (negative) */
-    amount: Web3Number;
-    /** Collateral token info */
-    collateralToken: TokenInfo;
-    /** Debt token info */
-    debtToken: TokenInfo;
-}
-/** Realise PnL on Extended exchange */
-interface RealisePnlRoute extends RouteBase {
-    type: RouteType.REALISE_PNL;
-    /** Amount of PnL to realise (the shortfall beyond available-to-withdraw) */
-    amount: Web3Number;
-    /** Extended instrument name (e.g. "BTC-USD") */
-    instrument: string;
-}
-/** Increase / decrease leverage on Extended exchange */
-interface ExtendedLeverRoute extends RouteBase {
-    type: RouteType.EXTENDED_INCREASE_LEVER | RouteType.EXTENDED_DECREASE_LEVER;
-    /** Change in exposure denominated in the exposure token */
-    amount: Web3Number;
-    /** Extended instrument name (e.g. "BTC-USD") */
-    instrument: string;
-}
-/** Crisis: temporarily increase / undo max leverage on Extended — no args for now */
-interface CrisisExtendedLeverRoute extends RouteBase {
-    type: RouteType.CRISIS_INCREASE_EXTENDED_MAX_LEVERAGE | RouteType.CRISIS_UNDO_EXTENDED_MAX_LEVERAGE;
-}
-/** Crisis: borrow beyond the normal target HF */
-interface CrisisBorrowRoute extends RouteBase {
-    type: RouteType.CRISIS_BORROW_BEYOND_TARGET_HF;
-    /** Pool to borrow from */
-    poolId: ContractAddr;
-    /** Token being borrowed */
-    token: string;
-    /** Amount to borrow */
-    amount: Web3Number;
-}
-/** Bring liquidity from vault allocator to vault contract for user withdrawals */
-interface BringLiquidityRoute extends RouteBase {
-    type: RouteType.BRING_LIQUIDITY;
-    /** Amount to bring */
-    amount: Web3Number;
-}
-/** Control routes: RETURN_TO_WAIT (stop execution, resume in next cycle) */
-interface WaitRoute extends RouteBase {
-    type: RouteType.RETURN_TO_WAIT;
-}
-/**
- * A single step in the execution plan produced by the solver.
- * Discriminated union keyed on `type` — each variant carries only
- * the metadata that specific route needs.
- */
-type ExecutionRoute = TransferRoute | SwapRoute | VesuMultiplyRoute | VesuDebtRoute | RealisePnlRoute | ExtendedLeverRoute | CrisisExtendedLeverRoute | CrisisBorrowRoute | BringLiquidityRoute | WaitRoute;
-/**
- * Broad category of a detected case. Multiple categories may apply simultaneously.
- */
-declare enum CaseCategory {
-    LTV_REBALANCE = "LTV_REBALANCE",
-    NEW_DEPOSITS = "NEW_DEPOSITS",
-    WITHDRAWAL = "WITHDRAWAL",
-    EXPOSURE_IMBALANCE = "EXPOSURE_IMBALANCE",
-    MARGIN_CRISIS = "MARGIN_CRISIS"
-}
-/**
- * Specific case IDs corresponding to the situations defined in cases.json.
- */
-declare enum CaseId {
-    MANAGE_LTV = "MANAGE_LTV",
-    /** @deprecated use MANAGE_LTV */ LTV_VESU_LOW_TO_EXTENDED = "LTV_VESU_LOW_TO_EXTENDED",
-    /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_PROFITABLE_AVAILABLE = "LTV_EXTENDED_PROFITABLE_AVAILABLE",
-    /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_PROFITABLE_REALIZE = "LTV_EXTENDED_PROFITABLE_REALIZE",
-    /** @deprecated use MANAGE_LTV */ LTV_VESU_HIGH_USE_VA_OR_WALLET = "LTV_VESU_HIGH_USE_VA_OR_WALLET",
-    /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_HIGH_USE_VA_OR_WALLET = "LTV_EXTENDED_HIGH_USE_VA_OR_WALLET",
-    DEPOSIT_FRESH_VAULT = "DEPOSIT_FRESH_VAULT",
-    DEPOSIT_EXTENDED_AVAILABLE = "DEPOSIT_EXTENDED_AVAILABLE",
-    DEPOSIT_VESU_BORROW_CAPACITY = "DEPOSIT_VESU_BORROW_CAPACITY",
-    DEPOSIT_COMBINATION = "DEPOSIT_COMBINATION",
-    WITHDRAWAL_SIMPLE = "WITHDRAWAL_SIMPLE",
-    MARGIN_CRISIS_EXTENDED = "MARGIN_CRISIS_EXTENDED",
-    MARGIN_CRISIS_VESU = "MARGIN_CRISIS_VESU",
-    IMBALANCE_EXTENDED_EXCESS_SHORT_NO_FUNDS = "IMBALANCE_EXTENDED_EXCESS_SHORT_NO_FUNDS",
-    IMBALANCE_EXTENDED_EXCESS_SHORT_HAS_FUNDS = "IMBALANCE_EXTENDED_EXCESS_SHORT_HAS_FUNDS",
-    IMBALANCE_VESU_EXCESS_LONG_NO_FUNDS = "IMBALANCE_VESU_EXCESS_LONG_NO_FUNDS",
-    IMBALANCE_VESU_EXCESS_LONG_HAS_FUNDS = "IMBALANCE_VESU_EXCESS_LONG_HAS_FUNDS"
-}
-/**
- * A detected case describing the current system state and the
- * high-level steps required to resolve it.
- */
-interface SolveCase {
-    id: CaseId;
-    category: CaseCategory;
-    title: string;
-    description: string;
-    /** High-level steps describing what needs to happen for this case */
-    steps: string[];
-}
-/** Decimal places for rounding collateral / exposure deltas in token terms (e.g. BTC) */
-declare const COLLATERAL_PRECISION = 4;
-/**
- * A single detected case with its metadata, amounts, and the execution
- * routes that belong to this case.
- */
-interface SolveCaseEntry {
-    case: SolveCase;
-    additionalArgs: {
-        amount?: Web3Number;
-    };
-    routes: ExecutionRoute[];
-}
-/**
- * Maps each CaseId to the RouteTypes that are relevant for resolving it.
- * Used to filter the global route list into per-case route subsets.
- */
-declare const CASE_ROUTE_TYPES: Record<CaseId, RouteType[]>;
-/**
- * Complete output from the solver describing all needed state changes.
- *
- * - cases:                    detected cases describing the system state and needed actions.
- * - extendedDeposit:          positive = deposit USDC into Extended, negative = withdraw.
- * - extendedPositionDeltas:   per-instrument exposure changes (with instrument id).
- * - vesuDeltas:               per-pool debt & collateral changes (with pool id and token pair).
- * - vesuAllocationUsd:        USDC directed to Vesu side (negative = unwind from Vesu).
- * - extendedAllocationUsd:    USDC directed to Extended side (negative = withdraw from Extended).
- * - bringLiquidityAmount:     amount VA should send via bringLiquidity to the vault
- *                             (= withdrawAmount input; 0 during investment cycles).
- */
-interface SolveResult {
-    /** Detected cases describing the current situation, amounts, and per-case routes */
-    cases: SolveCaseEntry[];
-    extendedDeposit: Web3Number;
-    extendedPositionDeltas: ExtendedPositionDelta[];
-    vesuDepositAmount: Web3Number;
-    vesuDeltas: VesuPoolDelta[];
-    vesuAllocationUsd: Web3Number;
-    extendedAllocationUsd: Web3Number;
-    bringLiquidityAmount: Web3Number;
-    /**
-     * Net pending deposit for Extended.
-     * Positive = deposit in transit (wallet → Extended), negative = withdrawal in transit.
-     * Used by ExecutionService to avoid double-sending transfers.
-     */
-    pendingDeposit: Web3Number;
-}
-interface StateManagerConfig {
-    pricer: PricerBase;
-    networkConfig: IConfig;
-    vesuAdapters: VesuMultiplyAdapter[];
-    extendedAdapter: ExtendedAdapter;
-    vaultAllocator: ContractAddr;
-    walletAddress: string;
-    /** Strategy / vault token — idle balance in the vault allocator is denominated in this asset */
-    assetToken: TokenInfo;
-    /**
-     * Native USDC (Starknet) — operator wallet stablecoin balance is always read for this token,
-     * independent of {@link assetToken} (e.g. when the strategy vault uses another asset).
-     */
-    usdcToken: TokenInfo;
-    /** Collateral token (e.g. WBTC) for wallet balance checks */
-    collateralToken: TokenInfo;
-    limitBalanceBufferFactor: number;
-}
-/**
- * Returns a short human-readable summary of a route's key fields for logging.
- */
-declare function routeSummary(r: ExecutionRoute): string;
-/**
- * Single source of truth for all mutable state during a solve() call.
- *
- * Stores **raw** snapshots from refresh (no safety buffer applied in fields).
- * Buffer {@link limitBalanceBufferFactor} is applied only in **getters** used
- * during solve (caps, diagnostics). **Spend / add** methods mutate balances
- * in **raw** USD only (no buffer on debits or credits).
- *
- * **Extended deposits** ({@link SolveBudget.addToExtAvailTrade}): while account equity is
- * below required margin (Σ position value ÷ Extended leverage), incoming USDC is credited
- * only to **balance** and **equity**. Only the excess is credited to **availableForWithdrawal**
- * and **availableForTrade**, matching “margin first, then free collateral”.
- */
-declare class SolveBudget {
-    private unusedBalance;
-    private walletBalance;
-    /**
-     * Idle non-stable {@link StateManagerConfig.assetToken} in the vault allocator.
-     * Null when asset and USDC are the same token (VA idle stablecoin is only in {@link vaultUsdcBalance}).
-     */
-    private vaultAssetBalance;
-    /** Idle {@link StateManagerConfig.usdcToken} in the vault allocator (including when it is also the strategy asset). */
-    private vaultUsdcBalance;
-    private extendedPositions;
-    private extendedBalance;
-    private vesuPoolStates;
-    private vesuPerPoolDebtDeltasToBorrow;
-    private shouldVesuRebalance;
-    readonly assetToken: TokenInfo;
-    readonly usdcToken: TokenInfo;
-    constructor(state: {
-        assetToken: TokenInfo;
-        usdcToken: TokenInfo;
-        unusedBalance: TokenBalance[];
-        walletBalance: TokenBalance | null;
-        vaultAssetBalance: TokenBalance | null;
-        vaultUsdcBalance: TokenBalance | null;
-        extendedPositions: ExtendedPositionState[];
-        extendedBalance: ExtendedBalanceState | null;
-        vesuPoolStates: VesuPoolState[];
-    });
-    /** `1 - limitBalanceBufferFactor` — multiplier applied to raw notionals for “usable” USD. */
-    private _usableFraction;
-    /**
-     * Raw USD notional for a token row. USDC (and configured {@link usdcToken}) uses 1:1 from amount;
-     * non-stable assets (e.g. WBTC in VA) use {@link TokenBalance.usdValue} from the pricer at refresh.
-     */
-    private _rawTokenUsd;
-    /** Apply safety buffer to a raw USD scalar. */
-    bufferedUsd(rawUsd: number): number;
-    /** Convert a buffered “usable” USD amount to raw nominal USD (inverse of {@link bufferedUsd}). */
-    rawUsdFromBuffered(bufferedUsd: number): number;
-    /** Buffered USD notional for one token balance row. */
-    bufferedTokenUsd(tb: TokenBalance | null | undefined): number;
-    logStateSummary(): {
-        unusedBalances: {
-            token: string;
-            amount: number;
-        }[];
-        walletBalance: {
-            token: string;
-            amount: number;
-        } | undefined;
-        vaultAssetBalance: {
-            token: string;
-            amount: number;
-        } | undefined;
-        vaultUsdcBalance: {
-            token: string;
-            amount: number;
-        } | undefined;
-        vesuPoolStates: {
-            poolId: ContractAddr;
-            collateralAmount: number;
-            debtAmount: number;
-        }[];
-        vesuBorrowCapacity: number;
-        vesuRebalance: boolean[];
-        vesuPerPoolDebtDeltasToBorrow: number[];
-        extendedBalance: number | undefined;
-        extendedEquity: number | undefined;
-        extendedAvailableForTrade: number | undefined;
-        extendedAvailableForWithdrawal: number | undefined;
-        extendedUnrealisedPnl: number | undefined;
-        extendedPendingDeposit: number | undefined;
-        extendedPositions: {
-            instrument: string;
-            size: number;
-            valueUsd: number;
-        }[];
-    };
-    /**
-     * Initialise derived views for a solve cycle. Mutates only when pending
-     * withdrawal from Extended is in transit (credits wallet raw balance).
-     */
-    initBudget(): void;
-    /**
-     * Apply a safety buffer to all liquid balances (VA, wallet, extended trade/withdraw/upnl,
-     * unused balances). Call after withdrawal classification but before LTV/deposit classifiers
-     * so that withdrawal uses full raw amounts while subsequent classifiers see buffered values.
-     */
-    applyBuffer(factor: number): void;
-    get vesuPoolState(): VesuPoolState;
-    /** Buffered VA USD: non-stable asset slot (if any) + USDC slot. */
-    get vaUsd(): number;
-    /** Buffered USD in VA strategy-asset bucket only. */
-    get vaAssetUsd(): number;
-    /** Buffered USD in VA USDC bucket (includes full VA idle when asset === USDC). */
-    get vaUsdcUsd(): number;
-    get walletUsd(): number;
-    get vaWalletUsd(): number;
-    get extAvailWithdraw(): number;
-    get extAvailUpnl(): number;
-    /**
-     * Buffered Extended available-for-trade plus positive {@link ExtendedBalanceState.pendingDeposit}
-     * (deposit in transit is usable the same way as the pre-buffer implementation).
-     */
-    get extAvailTrade(): number;
-    get extPendingDeposit(): number;
-    /**
-     * Aggregate positive per-pool borrow headroom (USD). Repay/borrow routes update
-     * {@link vesuPerPoolDebtDeltasToBorrow}; no separate counter.
-     */
-    get vesuBorrowCapacity(): number;
-    /** Diagnostic: buffered idle + positive debt delta + buffered Extended afT + in-flight deposit. */
-    get totalUnused(): number;
-    /** Sum of buffered USD across merged unused-balance rows (VA + wallet). */
-    get unusedBalancesBufferedUsdSum(): number;
-    /** Read-only snapshot view for validation / logging. */
-    get unusedBalanceRows(): readonly TokenBalance[];
-    /** Read-only Vesu pool view for solve computations. */
-    get vesuPools(): readonly VesuPoolState[];
-    /** Read-only Extended positions view for solve computations. */
-    get extendedPositionsView(): readonly ExtendedPositionState[];
-    /** Read-only Extended balance view for diagnostics / margin checks. */
-    get extendedBalanceView(): ExtendedBalanceState | null;
-    /** Current debt deltas per pool (positive=borrow, negative=repay). */
-    get vesuDebtDeltas(): readonly Web3Number[];
-    /** Per-pool rebalance flags derived from target HF checks. */
-    get vesuRebalanceFlags(): readonly boolean[];
-    /** Raw USD in VA (USDC slot + non-stable asset slot when distinct); spend caps when executing transfers. */
-    private _vaRawUsd;
-    /** VA liquidity usable for repay / {@link spendVaRawUsd} (matches nominal balances after any {@link applyBuffer} scaling). */
-    get vaRawUsd(): number;
-    private _walletRawUsd;
-    /** Remove up to `usd` notional from a token balance, scaling token amount proportionally. */
-    private _deductUsdFromTokenBalance;
-    /** Add USD notional; infers price from current amount/usd when possible, else 1:1. */
-    private _addUsdToTokenBalance;
-    /**
-     * Rebuilds {@link unusedBalance} from vault + wallet snapshots (same merge as refresh).
-     */
-    private _recomputeUnusedBalance;
-    /**
-     * Spend VA **raw** USD (up to {@link vaRawUsd}). Prefer {@link vaultUsdcBalance} when present, then {@link vaultAssetBalance}.
-     */
-    spendVA(rawDesired: number): number;
-    /**
-     * Spend nominal/raw USD from VA (e.g. Vesu repay, on-chain USDC). Does not apply the safety buffer to the cap.
-     */
-    spendVaRawUsd(rawUsdDesired: number): number;
-    /**
-     * Add **raw nominal USD** to VA (borrow proceeds, wallet→VA in raw USDC, etc.).
-     */
-    addToVA(rawUsd: number): void;
-    spendWallet(rawDesired: number): number;
-    /** Add **raw nominal USD** to the operator wallet balance (e.g. Extended→wallet withdrawal). */
-    addToWallet(rawUsd: number): void;
-    spendVAWallet(rawDesired: number): number;
-    private _updateExtAvailWithdraw;
-    private _updateExtAvailUpnl;
-    spendExtAvailTrade(rawDesired: number): number;
-    spendExtAvailTradeToEquityOnly(rawDesired: number): number;
-    spendExtAvailWithdraw(rawDesired: number): number;
-    spendExtAvailUpnl(rawDesired: number): number;
-    /**
-     * Withdraw from Extended **withdrawal bucket only** to operator wallet (planning).
-     * Used when VA must be funded from Extended and withdraw should be exhausted before unrealised PnL.
-     */
-    spendAvailWithdrawToWallet(rawDesired: number): number;
-    /**
-     * Required Extended equity (USD) for current open positions: total notional ÷ strategy leverage.
-     * Same basis as {@link ExtendedSVKVesuStateManager._classifyLtvExtended} margin check.
-     */
-    private _extendedMarginRequirementUsd;
-    /** How much more equity is needed before deposits should increase withdraw / trade availability. */
-    private _extendedEquityShortfallUsd;
-    /**
-     * Credits a USDC inflow on Extended. Fills margin shortfall (balance+equity only) first;
-     * any remainder is credited across balance, equity, availableForWithdrawal, and availableForTrade.
-     */
-    addToExtAvailTrade(rawUsd: number): void;
-    spendVesuBorrowCapacity(desired: number): {
-        used: number;
-        spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[];
-    };
-    repayVesuBorrowCapacity(desired: number): {
-        used: number;
-        spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[];
-    };
-    /** Update a Vesu pool's collateral and debt after a lever / borrow / repay route. */
-    applyVesuDelta(poolId: ContractAddr, collToken: TokenInfo, debtToken: TokenInfo, collDelta: Web3Number, debtDelta: Web3Number): void;
-    /**
-     * Update Extended position size after a lever route; sync {@link ExtendedPositionState.valueUsd}
-     * and margin buckets (released USD on decrease, locked USD on increase).
-     *
-     * @param collateralPriceUsd BTC collateral price for notional / margin math; if omitted, uses
-     *        existing valueUsd / |size| or the first Vesu pool collateral price.
-     */
-    applyExtendedExposureDelta(instrument: string, sizeDelta: Web3Number, collateralPriceUsd?: number): void;
-    /** Pull margin for larger Extended exposure from liquid buckets, then balance/equity. */
-    private _lockExtendedMarginUsd;
-    /**
-     * For each Vesu pool, computes the debt delta needed to bring the position
-     * back to the target health factor.
-     *
-     * Positive = can borrow more, negative = need to repay.
-     */
-    private _computeperPoolDebtDeltasToBorrow;
-}
-declare function createSolveBudgetFromRawState(params: {
-    assetToken: TokenInfo;
-    usdcToken: TokenInfo;
-    unusedBalance: TokenBalance[];
-    walletBalance: TokenBalance | null;
-    vaultAssetBalance: TokenBalance | null;
-    vaultUsdcBalance: TokenBalance | null;
-    extendedPositions: ExtendedPositionState[];
-    extendedBalance: ExtendedBalanceState | null;
-    vesuPoolStates: VesuPoolState[];
-    limitBalanceBufferFactor?: number;
-}): SolveBudget;
-/**
- * Reads all on-chain / off-chain state for the Extended + SVK + Vesu strategy,
- * then solves for the optimal rebalancing deltas.
- *
- * Usage:
- *   const manager = new ExtendedSVKVesuStateManager(config);
- *   const result  = await manager.solve();
- */
-declare class ExtendedSVKVesuStateManager {
-    private readonly _config;
-    private readonly _tag;
-    /** Single mutable state holder — initialised by _refresh(), budget by initBudget(). */
-    private _budget;
-    constructor(config: StateManagerConfig);
-    /**
-     * Main entry point. Refreshes all state, then computes and returns
-     * the optimal deltas for rebalancing the strategy.
-     *
-     * @param withdrawAmount — amount (in vault asset, e.g. USDC) the user wants
-     *   to withdraw. When > 0 the solver shrinks protocol allocations so that the
-     *   vault allocator ends up with enough balance to execute bringLiquidity.
-     *   Pass 0 (default) for normal investment / rebalancing cycles.
-     */
-    solve(withdrawAmount?: Web3Number): Promise<SolveResult | null>;
-    /**
-     * Reads all on-chain and off-chain state in parallel and stores
-     * results in private instance variables.
-     */
-    private _refresh;
-    /** True when strategy asset and USDC share one token — VA idle balance is tracked as USDC, not as asset. */
-    private _vaultAssetAndUsdcAreSameToken;
-    /**
-     * Reads idle {@link StateManagerConfig.assetToken} in the vault allocator when it differs from USDC.
-     * When asset and USDC are the same token, returns null (that balance is reported via {@link _fetchVaultAllocatorUsdcBalanceIfDistinct} only).
-     */
-    private _fetchVaultAllocatorAssetBalance;
-    /**
-     * Reads {@link StateManagerConfig.usdcToken} idle in the vault allocator (always — distinct asset or USDC-as-asset).
-     */
-    private _fetchVaultAllocatorUsdcBalanceIfDistinct;
-    /**
-     * Merges vault-allocator asset (if any), vault-allocator USDC, and operator wallet
-     * balances into entries keyed by token address.
-     */
-    private _computeUnusedBalances;
-    /**
-     * Reads the operator wallet balance for {@link StateManagerConfig.usdcToken} only
-     * (wallet stablecoin is always USDC, regardless of strategy {@link StateManagerConfig.assetToken}).
-     */
-    private _fetchWalletBalances;
-    /**
-     * Reads the Extended exchange account-level balance (equity, available for
-     * trade/withdrawal, etc.). Returns null if the API call fails.
-     */
-    private _fetchExtendedBalance;
-    /**
-     * Computes the net pending deposit by subtracting pending withdrawals from
-     * pending deposits. Uses the Extended exchange asset operations API.
-     *
-     * Positive = deposit in transit (wallet → Extended).
-     * Negative = withdrawal in transit (Extended → wallet).
-     */
-    private _fetchPendingDeposit;
-    /**
-     * Reads all open positions on the Extended exchange. Each position
-     * includes instrument, side, size, USD value, and leverage.
-     */
-    private _fetchExtendedPositions;
-    /**
-     * Reads a single Vesu pool's position data: collateral amount/price,
-     * debt amount/price.
-     */
-    private _fetchSingleVesuPoolState;
-    /**
-     * Reads all Vesu pool states in parallel (one per configured adapter).
-     */
-    private _fetchAllVesuPoolStates;
-    /**
-     * Validates that all critical refreshed state is present and contains
-     * finite, sensible values. Throws on invalid state.
-     */
-    private _validateRefreshedState;
-    private _validateTokenBalanceOrThrow;
-    private _validateVesuPoolPricesOrThrow;
-    private _validateExtendedBalanceOrThrow;
-    private _assertPositiveFinite;
-    /**
-     * Computes total distributable capital by combining idle vault balance
-     * and Extended available balance, then adjusting for aggregate debt
-     * delta and any pending withdrawal.
-     *
-     * When withdrawAmount > 0 the distributable pool shrinks, forcing the
-     * allocation split to produce smaller (or negative) allocations — which
-     * in turn causes protocol positions to unwind and free capital for the
-     * vault allocator to execute bringLiquidity.
-     */
-    private _computeDistributableAmount;
-    /**
-     * Total investable = vault allocator balance + Extended available-for-trade +
-     * buffered unrealised PnL, matching `deposit_cases_extended_vesu.xlsx`:
-     * `(VA + wallet + EXT_WITH_AVL + EXT_UPNL) * (1 − buffer)`.
-     * Positive {@link ExtendedBalanceState.pendingDeposit} stays on the afT leg only (see {@link SolveBudget.extAvailTrade}).
-     */
-    private _computeTotalInvestableAmount;
-    private _sumDebtDeltas;
-    /**
-     * Splits distributable capital between Vesu and Extended using leverage
-     * ratios and existing exposure to match delta-neutral targets.
-     *
-     * Formula (from existing strategy):
-     *   ExtendedAlloc = (vL * distributable + vesuExposure - extendedExposure) / (vL + eL)
-     *   VesuAlloc     = distributable - ExtendedAlloc
-     */
-    private _computeAllocationSplit;
-    private _hasNoVesuAdapters;
-    /**
-     * Distributes the total Vesu USD allocation across pools proportionally
-     * by existing collateral value, then converts each share to collateral
-     * token units.
-     */
-    private _computePerPoolCollateralDeltas;
-    /**
-     * Determines how much of the total Vesu allocation goes to a single pool.
-     * Single-pool or zero-total cases get the entire allocation.
-     * Multi-pool cases split proportionally by current collateral USD value.
-     */
-    private _computePoolCollateralShare;
-    /**
-     * Computes per-position exposure deltas for delta neutrality.
-     * Target: total Extended short exposure = total projected Vesu collateral
-     * exposure (current + collateral deltas).
-     */
-    private _computeExtendedPositionDeltas;
-    /**
-     * Target Extended exposure = sum of (current collateral + collateralDelta)
-     * * price, across all Vesu pools.
-     */
-    private _computeTargetExtendedExposure;
-    private _hasNoExtendedPositions;
-    /**
-     * Creates a single-element delta array for the default instrument
-     * when no Extended positions currently exist.
-     */
-    private _singleInstrumentDelta;
-    /**
-     * Distributes a total exposure delta proportionally across existing
-     * positions by their current USD value share.
-     */
-    private _distributeExposureDeltaAcrossPositions;
-    /**
-     * Returns the fraction (0–1) of total Extended exposure held by
-     * a single position. Returns 1 when there is only one position
-     * or when total exposure is zero.
-     */
-    private _positionExposureShareFraction;
-    /**
-     * Net deposit change = allocation target − currently available for trade.
-     * Positive = need to deposit more, negative = can withdraw excess.
-     */
-    private _computeExtendedDepositDelta;
-    private _computeVesuDepositAmount;
-    /**
-     * The wallet is a pass-through for USDC flows between the vault allocator
-     * and the Extended exchange.
-     *
-     * Positive = vault allocator → wallet → Extended (deposit)
-     * Negative = Extended → wallet → vault allocator (withdrawal)
-     */
-    private _deriveWalletDelta;
-    /**
-     * The bringLiquidity amount is the USDC that the vault allocator must
-     * transfer back to the vault contract for the user's withdrawal.
-     * Equals the withdrawAmount passed into solve(); 0 during investment cycles.
-     */
-    private _computeBringLiquidityAmount;
-    private _buildVesuRepayRoutes;
-    private _buildVesuBorrowRoutes;
-    private _getWalletToVARoute;
-    private _getWalletToEXTENDEDRoute;
-    private _getVAToEXTENDEDRoute;
-    private _getExtendedToWalletRoute;
-    private _getWALLETToVARoute;
-    private _getUpnlRoute;
-    /**
-    * 1. Withdrawal — source funds in priority order:
-    *    1) VA balance  2) Wallet  3) Vesu borrow capacity
-    *    4) Extended available-for-withdrawal + unrealised PnL
-    *    5) Unwind positions on both sides (freed funds handled next cycle)
-    */
-    private _classifyWithdrawal;
-    /**
-     * 2a. LTV Rebalance — Vesu side
-     *
-     * Triggered when vesuPerPoolDebtDeltasToBorrow sum is negative (high LTV, needs repayment).
-     * Sources funds to VA so the subsequent deposit classifier can build the correct lever routes.
-     *
-     * Priority: 1) VA + Wallet (no routes)  2) Extended available-for-withdrawal
-     *           3) Extended uPnL  4) Margin crisis (future)
-     *
-     * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
-     */
-    /**
-     * Unified LTV / exposure classifier: `rebalance()` drives both LTV (debt, margin,
-     * funding) and Vesu↔Extended position alignment. There is no separate imbalance pass.
-     * Computes both Vesu repay and Extended margin needs,
-     * then builds all routes in a single pass with no duplicate transfers.
-     *
-     * Vesu repay priority: VA > Wallet > ExtAvl > ExtUpnl
-     * Extended margin priority: Wallet > VA > VesuBorrow
-     * Shared sources consumed by Vesu first (higher priority).
-     */
-    private _classifyLTV;
-    private _ltvRebalanceInputsFromBudget;
-    private _isLtvRebalanceNoop;
-    /**
-     * Turn pure rebalance() deltas into execution routes.
-     * Order: Vesu multiply decrease → Extended decrease → aggregated transfers
-     * (REALISE_PNL, EXTENDED_TO_WALLET + WAIT, WALLET_TO_VA, VESU_BORROW, VESU_REPAY, VA_TO_EXTENDED),
-     * then Vesu multiply increase and Extended increase (need VA / Extended funded first).
-     */
-    private _buildLtvRoutesFromRebalanceDeltas;
-    /**
-     * LTV_EXTENDED_PROFITABLE_AVAILABLE:
-     * Extended has enough available-to-withdraw → withdraw, move to VA, repay Vesu.
-     * Routes: [EXTENDED_TO_WALLET, WALLET_TO_VA, VESU_REPAY]
-     */
-    /**
-     * LTV_EXTENDED_PROFITABLE_REALIZE:
-     * Extended has unrealised PnL → realise it first, then withdraw + repay.
-     * Routes: [REALISE_PNL, EXTENDED_TO_WALLET, WALLET_TO_VA, VESU_REPAY]
-     */
-    /**
-     * MARGIN_CRISIS_VESU:
-     * Neither VA/Wallet nor Extended withdrawal covers the shortfall.
-     * Temporarily increase Extended leverage to free margin, withdraw to VA, then
-     * decrease Vesu lever to bring LTV back in range.
-     * Routes: [CRISIS_INCREASE_EXTENDED_MAX_LEVERAGE, EXTENDED_TO_WALLET, WALLET_TO_VA,
-     *          VESU_MULTIPLY_DECREASE_LEVER, EXTENDED_DECREASE_LEVER, CRISIS_UNDO_EXTENDED_MAX_LEVERAGE]
-     */
-    /**
-     * LTV_EXTENDED_HIGH_USE_VA_OR_WALLET:
-     * VA/Wallet has funds → route them to Extended.
-     * Routes: [VA_TO_EXTENDED, WALLET_TO_EXTENDED] (wallet-first, then VA for remainder)
-     */
-    /**
-     * LTV_VESU_LOW_TO_EXTENDED:
-     * Borrow USDC from Vesu, route through VA to Extended.
-     * Routes: [VESU_BORROW, VA_TO_EXTENDED]
-     */
-    /**
-     * MARGIN_CRISIS_EXTENDED:
-     * Borrow beyond target HF on Vesu to free USDC, deposit to Extended,
-     * then decrease Vesu/Extended lever, undo crisis leverage.
-     * Routes: [CRISIS_BORROW_BEYOND_TARGET_HF, VA_TO_EXTENDED,
-     *          VESU_MULTIPLY_DECREASE_LEVER, EXTENDED_DECREASE_LEVER,
-     *          CRISIS_UNDO_EXTENDED_MAX_LEVERAGE]
-     */
-    private _rebalanceFunds;
-    private _scaleVesuPoolDeltasByFactor;
-    /**
-     * 3. New Deposits / Excess Funds
-     *
-     * Computes how much exposure to create on Vesu and Extended, then
-     * distributes available funds using shortest-path priority chains:
-     *   Extended margin:  Wallet → VA → Vesu borrow
-     *   Vesu margin:      VA → Wallet → Extended
-     */
-    /**
-     * 3. New Deposits / Excess Funds
-     *
-     * Computes allocation split between Vesu and Extended, then sources
-     * funds and creates lever-increase routes.
-     *
-     * Order: {@link _rebalanceFunds} first → project VA / Extended liquid after the same funding
-     * routes (wallet→VA, borrow→VA, VA→Extended, Extended→wallet→VA) → ideal Vesu/Extended deltas
-     * from distributable split → cap common BTC by min(Vesu fundable, Extended fundable) → scale
-     * Vesu deltas and recompute Extended deltas so both sides stay matched.
-     *
-     * Fund flow (single pass — avoid VA→Extended then Extended→wallet round-trips):
-     *   1) Treat Vesu borrow headroom that the multiply route will consume as covering
-     *      part of the Vesu USDC need (no standalone VESU_BORROW for that slice). Cap
-     *      standalone VESU_BORROW→VA→Extended by remaining headroom.
-     *   2) Cover Extended deposit delta: REALISE_PNL first, then withdrawal→avail-trade,
-     *      then wallet→Extended, then VA→Extended only up to VA surplus above the USDC
-     *      that must remain for Vesu (after step 1), then borrow→VA→Extended.
-     *   3) Cover Vesu VA shortfall: wallet→VA, Extended withdrawal→wallet→VA, REALISE_PNL,
-     *      then combined Extended→wallet→VA for the remainder.
-     *   4) RETURN_TO_WAIT when needed; then AVNU + VESU_MULTIPLY + EXTENDED_INCREASE.
-     */
-    /**
-     * @param skipAvnuDepositSwap Omit AVNU before Vesu multiply when LTV cases already ran this cycle
-     *   (matrix tests expect deposit routes without that step).
-     */
-    private _classifyDeposits;
-    /** 4. Exposure Imbalance */
-    /**
-     * IMBALANCE_EXTENDED_EXCESS_SHORT_HAS_FUNDS:
-     * Extended has too much short exposure vs Vesu. Use VA/Wallet funds to
-     * add Vesu collateral and reduce Extended exposure.
-     *
-     * The new Vesu collateral covers part of the imbalance; the remaining
-     * gap is closed by reducing Extended short exposure.
-     *
-     * Routes: [AVNU_DEPOSIT_SWAP, VESU_MULTIPLY_INCREASE_LEVER, EXTENDED_DECREASE_LEVER]
-     */
-    /**
-     * IMBALANCE_EXTENDED_EXCESS_SHORT_NO_FUNDS:
-     * No available funds to add Vesu collateral → reduce Extended exposure
-     * by the full imbalance amount.
-     * Routes: [EXTENDED_DECREASE_LEVER]
-     */
-    private _buildImbalanceExtExcessShortNoFundsRoutes;
-    /**
-     * IMBALANCE_VESU_EXCESS_LONG_HAS_FUNDS:
-     * Vesu has too much long exposure vs Extended. Deposit funds on Extended
-     * to increase short exposure, and decrease Vesu lever for the remainder.
-     *
-     * Routes: [WALLET_TO_EXTENDED / VA_TO_EXTENDED, EXTENDED_INCREASE_LEVER,
-     *          VESU_MULTIPLY_DECREASE_LEVER]
-     */
-    /**
-     * IMBALANCE_VESU_EXCESS_LONG_NO_FUNDS:
-     * No funds to increase Extended → decrease Vesu lever by the full imbalance.
-     * Routes: [VESU_MULTIPLY_DECREASE_LEVER]
-     */
-    /**
-     * Classifies the current state into actionable cases. Each case carries
-     * its own execution routes with amounts and state info.
-     */
-    private _classifyCases;
-    private _totalVesuCollateral;
-    private _totalVesuCollateralUsd;
-    private _totalExtendedExposure;
-    private _totalExtendedExposureUsd;
-    private _logSolveResult;
-}
-
-/**
- * Transaction metadata that SDK generates and risk engine stores in DB.
- * This metadata is used to track transaction lifecycle without coupling SDK to DB.
- */
-interface TransactionMetadata {
-    protocolFrom: string;
-    protocolTo: string;
-    transactionType: 'DEPOSIT' | 'WITHDRAWAL' | 'NONE';
-    usdAmount: string;
-    status: 'COMPLETED' | 'FAILED' | 'PENDING';
-    cycleType: CycleType;
-}
-declare enum CycleType {
-    INVESTMENT = "INVESTMENT",
-    REBALANCE_PRICE_DROP = "REBALANCE_PRICE_DROP",
-    REBALANCE_PRICE_RISE = "REBALANCE_PRICE_RISE",
-    WITHDRAWAL = "WITHDRAWAL",
-    DELTA_NEUTRAL_ADJUSTMENT = "DELTA_NEUTRAL_ADJUSTMENT"
-}
-/**
- * Enhanced return type for operations that generate transactions.
- * Includes both the calls (for execution) and metadata (for DB storage).
- */
-interface TransactionResult<T = any> {
-    calls: Call[];
-    status: boolean;
-    transactionMetadata: TransactionMetadata;
-}
-/**
- * Key lifecycle event types emitted during execution.
- * Used by callers (e.g. risk engine) to hook into the execution pipeline
- * and persist state to DB, send alerts, etc.
- */
-declare enum ExecutionEventType {
-    /** Execution started — tx sent on-chain or order placed on exchange */
-    INITIATED = "INITIATED",
-    /** Execution completed successfully — tx confirmed / order filled */
-    SUCCESS = "SUCCESS",
-    /** Execution failed — tx reverted / order rejected / timeout */
-    FAILURE = "FAILURE"
-}
-/**
- * Metadata payload accompanying each execution lifecycle event.
- * Contains relevant identifiers, prices, and contextual information.
- */
-interface ExecutionEventMetadata {
-    /** Route type string (e.g. RouteType value) */
-    routeType?: string;
-    /** Human-readable route summary */
-    routeSummary?: string;
-    /** On-chain transaction hash (when available) */
-    txHash?: string;
-    /** Exchange order ID (for off-chain orders) */
-    orderId?: string;
-    /** Amount involved in the operation */
-    amount?: string;
-    /** Protocol name */
-    protocol?: string;
-    /** Actual execution price (for exchange orders) */
-    executionPrice?: number;
-    /** Limit price that was set */
-    limitPrice?: number;
-    /** Error message on failure */
-    error?: string;
-    /** On-chain calls that were built */
-    calls?: Call[];
-    /** Extensible: any extra metadata */
-    [key: string]: any;
-}
-/**
- * Callback invoked on key execution lifecycle events.
- * Callers can use this to save to DB, send notifications, log, etc.
- */
-type ExecutionCallback = (eventType: ExecutionEventType, metadata: ExecutionEventMetadata) => void | Promise<void>;
-
-interface ExecutionConfig {
-    networkConfig: IConfig;
-    pricer: PricerBase;
-    vesuMultiplyAdapter: VesuMultiplyAdapter;
-    vesuModifyPositionAdapter: VesuModifyPositionAdapter;
-    extendedAdapter: ExtendedAdapter;
-    avnuAdapter: AvnuAdapter;
-    usdcTransferAdapter: TokenTransferAdapter;
-    vaultAllocator: ContractAddr;
-    walletAddress: string;
-    wbtcToken: TokenInfo;
-    usdcToken: TokenInfo;
-    /**
-     * Returns the strategy's merkle tree (built from all leaf adapters).
-     * Used to generate proofs for adapter manage calls.
-     */
-    getMerkleTree: () => StandardMerkleTree;
-    /**
-     * Combines merkle proofs and ManageCall[] into a single on-chain Call
-     * that invokes `manage_vault_with_merkle_verification` on the manager contract.
-     */
-    getManageCall: (proofs: string[][], manageCalls: ManageCall[]) => Call;
-    /**
-     * Callback to get the bring-liquidity call from the strategy.
-     */
-    getBringLiquidityCall: (params: {
-        amount: Web3Number;
-    }) => Promise<Call>;
-    /**
-     * Optional callback invoked on key execution lifecycle events.
-     * Use to persist state to DB, send alerts, etc.
-     */
-    onExecutionEvent?: ExecutionCallback;
-    /**
-     * Acceptable slippage for Extended limit orders in basis points.
-     * E.g. 10 = 0.1%. Default: 10 (0.1%).
-     * For BUY orders: limitPrice = midPrice * (1 + slippage)
-     * For SELL orders: limitPrice = midPrice * (1 - slippage)
-     */
-    extendedAcceptableSlippageBps?: number;
-    /**
-     * Maximum acceptable price divergence between Extended and Vesu
-     * execution prices in basis points. Default: 50 (0.5%).
-     *
-     * During increase exposure (extended SHORT + vesu LONG):
-     *   (extendedPrice - vesuPrice) / vesuPrice must be > -maxDivergence
-     * During decrease exposure (extended BUY + vesu decrease):
-     *   (extendedPrice - vesuPrice) / vesuPrice must be < +maxDivergence
-     */
-    maxPriceDivergenceBps?: number;
-    /**
-     * Max time (ms) to wait for Extended limit order fill in coordinated
-     * dual-exchange mode. Default: 3000 (3 seconds).
-     */
-    extendedFillTimeoutMs?: number;
-}
-/**
- * Processes a {@link SolveResult} and translates each case's {@link ExecutionRoute}s into
- * concrete on-chain transaction calls (batched) or off-chain API operations.
- *
- * Key design principles:
- *
- * 1. **Case-based execution**: Cases are processed sequentially. Within each
- *    case, routes execute in priority order.
- *
- * 2. **RETURN_TO_WAIT**: When encountered, all pending on-chain calls are
- *    flushed and execution halts. The remaining routes will be re-computed
- *    in the next solve cycle once async operations (bridge, deposit credit) settle.
- *
- * 3. **On-chain batching**: Consecutive on-chain routes (Starknet calls) are
- *    accumulated into a single multicall batch. Off-chain routes (Extended API)
- *    flush the batch, execute independently, then resume accumulation.
- *
- * 4. **pendingDeposit awareness**: Transfers to Extended are reduced by any
- *    amount already in transit, avoiding double-sends.
- *
- * 5. **AVNU buffer**: Swap amounts use a 0.1% buffer to account for slippage.
- *
- * Usage:
- *   const executor = new ExecutionService(config);
- *   const results  = await executor.execute(solveResult);
- */
-declare class ExecutionService {
-    private readonly _config;
-    private readonly _tag;
-    private readonly _tokenSymbols;
-    private readonly _tokenDecimals;
-    private readonly _poolNames;
-    /**
-     * Remaining pending deposit budget (consumed during execution to avoid double-sends).
-     * Initialised from SolveResult.pendingDeposit at the start of execute().
-     */
-    private _pendingDepositRemaining;
-    /**
-     * Starknet account used for on-chain estimation in coordinated mode.
-     * Set at the start of execute() and valid for the duration of the call.
-     */
-    private _account;
-    constructor(config: ExecutionConfig);
-    /**
-     * Emits a lifecycle event via the configured callback (if present).
-     * Safe to call even when no callback is configured.
-     */
-    private _emitEvent;
-    private _getProofGroupsForManageCalls;
-    /**
-     * Builds a single manage call (manage_vault_with_merkle_verification) for an adapter.
-     *
-     * Pattern:
-     *  1. Calls adapter.getDepositCall / getWithdrawCall to get ManageCall[]
-     *  2. Gets merkle proofs for the adapter's leaves
-     *  3. Combines via getManageCall into a single on-chain Call
-     *
-     * Use this for any VA-routed operation that needs merkle proof verification.
-     */
-    private _buildAdapterManageCall;
-    private _getExtendedMidPrice;
-    /**
-     * Executes a limit order on Extended with acceptable slippage from mid spot price.
-     *
-     * Flow:
-     *  1. Set leverage on the market
-     *  2. Fetch orderbook → compute mid price
-     *  3. Apply configured slippage to derive limit price
-     *  4. Place IOC limit order at that price
-     *  5. Poll for fill status with retries
-     *
-     * Returns execution details including the fill price, or null on failure.
-     */
-    private _executeExtendedLimitOrder;
-    private _fetchExtendedOrderStatusWithRetries;
-    private _cancelExtendedOrderIfOpen;
-    private _executeExtendedLimitOrderWithRecovery;
-    /** ExecutionRoute types that change BTC exposure (on-chain or off-chain). */
-    private static readonly EXPOSURE_CHANGING_ROUTES;
-    /** ExecutionRoute types that correspond to increasing delta-neutral exposure. */
-    private static readonly INCREASE_EXPOSURE_ROUTES;
-    /** On-chain route types that change BTC exposure (Vesu side). */
-    private static readonly ON_CHAIN_EXPOSURE_ROUTES;
-    /** Off-chain Extended route types that change BTC exposure. */
-    private static readonly EXTENDED_EXPOSURE_ROUTES;
-    /**
-     * Validates that the price divergence between Extended (orderbook mid) and
-     * AVNU (actual on-chain swap price) is within acceptable limits.
-     *
-     * Mirrors the check from `checkPriceDifferenceBetweenAvnuAndExtended` in the
-     * strategy — see investmentOrchestrator.ts for the call-site pattern.
-     *
-     * For OPEN (increasing exposure): we SELL on Extended (short) and BUY on AVNU (long).
-     *   → Extended price should not be too far below AVNU price.
-     *   → (extendedMid − avnuPrice) / avnuPrice must be > −maxDivergence
-     *
-     * For CLOSE (decreasing exposure): we BUY on Extended (close short) and SELL on AVNU.
-     *   → Extended price should not be too far above AVNU price.
-     *   → (extendedMid − avnuPrice) / avnuPrice must be < +maxDivergence
-     *
-     * @param isIncreasingExposure true when opening/increasing delta-neutral position
-     * @throws if divergence exceeds configured maxPriceDivergenceBps
-     */
-    private _validatePriceDivergence;
-    /**
-     * Computes the net weighted execution price (USDC per BTC) across all adapters
-     * that have a stored SwapPriceInfo from the most recent call build.
-     *
-     * For deposit (USDC→BTC): price = sum(USDC sold) / sum(BTC bought)
-     * For withdraw (BTC→USDC): price = sum(USDC bought) / sum(BTC sold)
-    * @returns no-swap means, logic is fine and explicit no swap is needed
-    */
-    private _getNetExecutionPrice;
-    /** Clears cached swap price info on all adapters to prevent stale data across cycles. */
-    private _clearAdapterPriceInfo;
-    /**
-     * Main entry point: takes a SolveResult and executes all cases in order,
-     * building the necessary transaction calls.
-     *
-     * - Cases are processed sequentially.
-     * - Within a case, on-chain calls are batched; off-chain calls flush the batch.
-     * - Dual-exchange exposure cases use the coordinated path (construct → estimate → fill Extended → send on-chain).
-     * - RETURN_TO_WAIT halts execution for the current case and all subsequent cases.
-     * - Execution stops on the first route failure.
-     *
-     * @param account Starknet account used for on-chain fee estimation in coordinated mode.
-     * @returns Ordered list of TransactionResults (one per batch/off-chain op).
-     */
-    execute(solveResult: SolveResult, account: Account): Promise<TransactionResult[]>;
-    /**
-     * Executes a single case's routes.
-     *
-     * First splits routes at the first RETURN_TO_WAIT into an "active window"
-     * (routes that will execute this cycle). If the active window contains both
-     * on-chain and off-chain exposure routes, delegates to the coordinated
-     * dual-exchange path. Otherwise, uses the standard route-by-route flow.
-     */
-    private _executeCase;
-    /**
-     * Standard route-by-route execution for non-coordinated cases.
-     *
-     * On-chain routes are accumulated into a Call[] batch. When an off-chain
-     * route or RETURN_TO_WAIT is encountered, the batch is flushed first.
-     */
-    private _executeStandardCase;
-    /**
-     * Coordinated execution for cases that touch both Vesu (on-chain) and
-     * Extended (off-chain) exposure in the same case.
-     *
-     * Flow:
-     *  1. Partition active routes into on-chain vs Extended
-     *  2. Construct all on-chain calls in parallel
-     *  3. Estimate on-chain batch (dry-run via account.estimateInvokeFee)
-     *  4. Validate price divergence between Extended and AVNU
-     *  5. Race Extended limit order fill against timeout
-     *  6. If filled → return Extended result + on-chain batch
-     *     If timeout/failure → drop everything
-     *
-     * // TODO: If Extended fills but the orchestrator's on-chain multicall later
-     * // reverts, we have an unhedged Extended position. The orchestrator should
-     * // catch the on-chain failure, re-solve with updated state to recompute
-     * // necessary on-chain calls, and retry. This recovery is non-trivial and
-     * // should be implemented as a follow-up.
-     */
-    private _executeCoordinatedCase;
-    /** Returns true if the route produces Starknet Call objects (on-chain tx). */
-    private _isOnChainRoute;
-    /** Checks whether any route in the list is a RETURN_TO_WAIT sentinel. */
-    private _caseHitReturnToWait;
-    /**
-     * Returns true when the active window contains both on-chain exposure
-     * routes (Vesu/AVNU) and off-chain Extended exposure routes — meaning
-     * both exchanges participate in the same exposure change and should be
-     * executed via the coordinated (fill-or-abort) path.
-     */
-    private _isDualExchangeCase;
-    /** Dispatches an on-chain route to the appropriate call builder. */
-    private _buildOnChainCalls;
-    /**
-     * WALLET_TO_EXTENDED: Deposit USDC from operator wallet directly to Extended.
-     *
-     * Builds raw approve + deposit calls (NOT through the manager/merkle system)
-     * because the wallet interacts with Extended directly, not via vault allocator.
-     *
-     * Adjusts amount by pending deposit to avoid double-sending.
-     */
-    private _buildWalletToExtendedCalls;
-    /**
-     * VA_TO_EXTENDED: Deposit USDC from vault allocator to Extended.
-     *
-     * Uses the extended adapter's getDepositCall to build ManageCalls,
-     * then wraps them in a merkle-verified manage call through the manager contract.
-     *
-     * Adjusts amount by pending deposit to avoid double-sending.
-     */
-    private _buildVAToExtendedCalls;
-    /**
-     * WALLET_TO_VA: Transfer USDC from operator wallet to vault allocator.
-     * Caps amount by actual wallet balance.
-     */
-    private _buildWalletToVACalls;
-    /**
-     * AVNU_DEPOSIT_SWAP: Standalone USDC → BTC swap via AVNU.
-     *
-     * Uses avnu adapter's getDepositCall to build swap ManageCalls,
-     * then wraps in a merkle-verified manage call.
-     * Applies 0.1% buffer so downstream Vesu deposit has sufficient BTC.
-     */
-    private _buildAvnuDepositSwapCalls;
-    /**
-     * AVNU_WITHDRAW_SWAP: Standalone BTC → USDC swap via AVNU.
-     *
-     * Uses avnu adapter's getWithdrawCall to build swap ManageCalls,
-     * then wraps in a merkle-verified manage call.
-     * Applies 0.1% buffer so Vesu-returned BTC is sufficient for the swap.
-     */
-    private _buildAvnuWithdrawSwapCalls;
-    /**
-     * VESU_MULTIPLY_INCREASE_LEVER: Compound operation.
-     *  1. AVNU swap USDC → BTC (with 0.1% buffer on collateral amount)
-     *  2. Vesu multiply deposit — add BTC as collateral (triggers flash-loan leverage)
-     *
-     * Both steps go through the merkle-verified manager contract via their respective adapters.
-     */
-    private _buildVesuIncreaseLeverCalls;
-    /**
-     * VESU_MULTIPLY_DECREASE_LEVER: Compound operation.
-     *  1. Vesu multiply withdraw — reduce BTC collateral (repays proportional debt via flash-loan)
-     *  2. AVNU swap BTC → USDC (with 0.1% buffer to account for slippage)
-     *
-     * Both steps go through the merkle-verified manager contract via their respective adapters.
-     */
-    private _buildVesuDecreaseLeverCalls;
-    private _validateVesuDebtRoute;
-    /**
-     * VESU_BORROW: Borrow additional USDC from Vesu.
-     */
-    private _buildVesuBorrowCalls;
-    /**
-     * VESU_REPAY: Repay USDC debt to Vesu.
-     */
-    private _buildVesuRepayCalls;
-    /** BRING_LIQUIDITY: Transfer from VA to vault contract for user withdrawals. */
-    private _buildBringLiquidityCalls;
-    /**
-     * CRISIS_BORROW_BEYOND_TARGET_HF: Borrow beyond normal target HF.
-     * TODO: Implement crisis borrow flow when needed.
-     */
-    private _buildCrisisBorrowCalls;
-    /** Dispatches an off-chain route to the appropriate executor. */
-    private _executeOffChainRoute;
-    /**
-     * EXTENDED_TO_WALLET: Withdraw from Extended exchange to operator wallet.
-     *
-     * This initiates the off-chain withdrawal API call. When followed by
-     * RETURN_TO_WAIT, the executor will halt and the next solve cycle picks up
-     * once the withdrawal settles and wallet balance is updated.
-     *
-     * If a pending withdrawal is already in transit (pendingDeposit < 0),
-     * the amount is reduced accordingly.
-     */
-    private _executeExtendedToWallet;
-    /**
-     * REALISE_PNL: Converts unrealised PnL to realised by closing a portion
-     * of the short position and immediately reopening it.
-     *
-     * Uses {@link calculatePositionToCloseToWithdrawAmount} to determine the
-     * minimal position size to close so that the required amount becomes
-     * available for withdrawal.
-     *
-     * Both close and reopen orders use limit pricing via _executeExtendedLimitOrder.
-     *
-     * Steps:
-     *  1. Close portion of short position (BUY limit order) → realises PnL
-     *  2. Immediately reopen same size (SELL limit order) → maintains exposure
-     */
-    private _executeRealisePnl;
-    /**
-     * EXTENDED_INCREASE_LEVER: Create a SHORT sell limit order on Extended to
-     * increase delta-neutral exposure.
-     *
-     * Uses limit pricing: limitPrice = midPrice * (1 - slippage) to prevent
-     * selling at unfavourable rates.
-     *
-     * Validates price divergence between Extended and Vesu before execution.
-     */
-    private _executeExtendedIncreaseLever;
+    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
+    getVesuMultiplyAdapter(): VesuMultiplyAdapter;
+    getVesuModifyPositionAdapter(): VesuModifyPositionAdapter;
     /**
-     * EXTENDED_DECREASE_LEVER: Close portion of SHORT position on Extended
-     * by placing a BUY limit order.
-     *
-     * Uses limit pricing: limitPrice = midPrice * (1 + slippage) to prevent
-     * buying at unfavourable rates.
-     *
-     * Validates price divergence between Extended and Vesu before execution.
+     * Legacy helper for retired Evergreen flows. New integrations should use
+     * getVesuMultiplyAdapter / getVesuModifyPositionAdapter and BaseAdapter deposit/withdraw leaves.
      */
-    private _executeExtendedDecreaseLever;
+    getVesuAdapters(): VesuAdapter[];
+    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
     /**
-     * CRISIS_INCREASE_EXTENDED_MAX_LEVERAGE: Temporarily increase Extended
-     * leverage to the crisis maximum (e.g. 4x) to free margin.
+     * Compatibility helper: SVKStrategy's `getManageCall` expects proof-groups.
+     * We derive proof-groups from each manageCall's `proofReadableId`.
      */
-    private _executeCrisisIncreaseLeverage;
+    protected getManageCallFromManageCalls(manageCalls: ManageCall[]): Call;
+    getVesuModifyPositionCalls(params: {
+        isLeg1: boolean;
+        isDeposit: boolean;
+        depositAmount: Web3Number;
+        debtAmount: Web3Number;
+    }): UniversalManageCall[];
+    getTag(): string;
     /**
-     * CRISIS_UNDO_EXTENDED_MAX_LEVERAGE: Revert Extended leverage back to
-     * the normal calculated level.
+     * Gets LST APR for the strategy's underlying asset from Endur API
+     * @returns Promise<number> The LST APR (not divided by 1e18)
      */
-    private _executeCrisisUndoLeverage;
+    getLSTAPR(address: ContractAddr): Promise<number>;
+    getVesuHealthFactors(blockNumber?: BlockIdentifier): Promise<number[]>;
+    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
+    private getNewHealthFactor;
     /**
-     * Adjusts a deposit-to-Extended amount by the remaining pending deposit
-     * budget. If pending deposit > 0, those funds are already in transit and
-     * shouldn't be re-sent.
      *
-     * Mutates `_pendingDepositRemaining` as the budget is consumed.
-     */
-    private _consumePendingDeposit;
-    /**
-     * Applies a 0.1% buffer (AVNU_BUFFER_FACTOR) to an amount.
-     * This ensures the downstream consumer (Vesu deposit or AVNU swap)
-     * always has sufficient tokens despite minor slippage.
-     */
-    private _applyAvnuBuffer;
-    /**
-     * Creates a TransactionResult for a batch of on-chain calls.
-     * The caller is expected to send all calls in a single multicall transaction.
+     * @param vesuAdapter
+     * @param currentHf
+     * @param isDeposit if true, attempt by adding collateral, else by repaying
+     * @returns
      */
-    private _onChainBatchResult;
-    private _successResult;
-    private _failureResult;
+    private getLegRebalanceAmount;
+    getVesuModifyPositionCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    getHarvestCall(): Promise<{
+        call: Call;
+        reward: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+    getRebalanceCall(params: {
+        isLeg1toLeg2: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
+}
+declare enum UNIVERSAL_MANAGE_IDS {
+    FLASH_LOAN = "flash_loan_init",
+    VESU_LEG1 = "vesu_leg1",
+    VESU_LEG2 = "vesu_leg2",
+    APPROVE_TOKEN1 = "approve_token1",
+    APPROVE_TOKEN2 = "approve_token2",
+    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
+    BRING_LIQUIDITY = "bring_liquidity",
+    DEFISPRING_REWARDS = "defispring_rewards",
+    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
+    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
+}
+declare enum UNIVERSAL_ADAPTER_IDS {
+    VESU_MULTIPLY = "vesu_multiply",
+    VESU_MODIFY = "vesu_modify",
+    AVNU = "avnu"
 }
+declare function getContractDetails(settings: UniversalStrategySettings & {
+    aumOracle?: ContractAddr;
+}): {
+    address: ContractAddr;
+    name: string;
+}[];
+declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
 
-interface VesuExtendedStrategySettings extends UniversalStrategySettings {
+interface HyperLSTStrategySettings extends UniversalStrategySettings {
+    borrowable_assets: {
+        tokenInfo: TokenInfo;
+        poolId: ContractAddr;
+    }[];
     underlyingToken: TokenInfo;
-    borrowable_assets: TokenInfo[];
-    targetHealthFactor: number;
     quoteAmountToFetchPrice: Web3Number;
+    targetHealthFactor: number;
     minHealthFactor: number;
     aumOracle: ContractAddr;
-    minimumWBTCDifferenceForAvnuSwap: number;
-    walletAddress: string;
+    adapterIds?: {
+        /** VesuMultiplyAdapter for underlying-matched debt (first matching borrowable pool) */
+        primaryMultiply: string;
+        multiply: Record<string, string>;
+        modify: Record<string, string>;
+    };
 }
-declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySettings> extends SVKStrategy<S> {
-    wbtcToken: TokenInfo;
-    usdcToken: TokenInfo;
-    readonly stateManager: ExtendedSVKVesuStateManager;
+declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
+    private quoteAmountToFetchPrice;
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
+    getTag(): string;
+    private getAdapterById;
+    getVesuMultiplyAdapterByKey(key: string): VesuMultiplyAdapter;
+    getVesuSameTokenAdapter(): VesuMultiplyAdapter;
+    getVesuMultiplyAdapters(): VesuMultiplyAdapter[];
+    getRewardsAUM(_prevAum: Web3Number): Promise<Web3Number>;
+    getLSTAvnuRate(): Promise<number>;
+    getLSTExchangeRate(): Promise<number>;
+    private _getMinOutputAmountLSTBuy;
+    private _getMinOutputAmountLSTSell;
     /**
-     * Extracts the required adapters from metadata and constructs the
-     * state manager used by shouldInvest / handleWithdraw.
+     * Uses vesu's multiple call to create leverage on LST
+     * Deposit amount is in LST
+     * @param params
      */
-    private _initializeStateManager;
+    getFundManagementCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call[] | null>;
+    getLSTUnderlyingTokenInfo(): TokenInfo;
+    getLSTAPR(_address: ContractAddr): Promise<number>;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    maxNewDeposits(params?: {
+        isAPYComputation: boolean;
+    }): Promise<number>;
+    protected getUnusedBalanceAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    getAUM(unrealizedAUM?: boolean): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: PositionInfo[];
+    }>;
+    getTVLUnrealized(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: PositionInfo[];
+    }>;
+    getUserUnrealizedGains(user: ContractAddr): Promise<{
+        unrealizedGains: Web3Number;
+        userShare: number;
+        tokenInfo: TokenInfo;
+    }>;
+}
+declare const AUDIT_URL = "https://docs.troves.fi/p/security#starknet-vault-kit";
+declare function getFAQs(lstSymbol: string, underlyingSymbol: string, isLST: boolean): FAQ[];
+declare const _riskFactor: RiskFactor[];
+declare function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string): string[];
+declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
+
+interface BoostedxSTRKCarryStrategySettings extends UniversalStrategySettings {
+    depositToken: TokenInfo;
+    debtToken: TokenInfo;
+    lstHyperToken: TokenInfo;
+    vesuPoolId: ContractAddr;
+    maxLTV: number;
+    targetLTV: number;
+    hyperLstVaultAddress: ContractAddr;
+    hyperLstRedeemNFT: ContractAddr;
+    trovesStrategyId: string;
+    hasBtcFiRewards: boolean;
+    adapterIds?: {
+        vesu: string;
+        avnu: string;
+        hyper: string;
+        transfer: string;
+    };
+}
+declare class BoostedxSTRKCarryStrategy<S extends BoostedxSTRKCarryStrategySettings> extends SVKStrategy<S> {
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
     getTag(): string;
+    private getAdapterById;
+    private getTruePriceForToken;
+    getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number): Promise<Web3Number>;
+    getMinOutputAmountLSTSell(amountInLST: Web3Number): Promise<Web3Number>;
+    getVesuModifyPositionCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+        debtAmount?: Web3Number;
+    }): Promise<Call>;
+    getVesuPositions(): Promise<VaultPosition[]>;
+    getVesuHealthFactor(blockNumber?: BlockIdentifier): Promise<number>;
+    getModifyHyperPositionCall(params: {
+        isDeposit: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
+    getAvnuSwapCall(params: {
+        isDeposit: boolean;
+        amount: Web3Number;
+        minAmount?: Web3Number;
+    }): Promise<Call>;
     /**
-     * Fetches current WBTC (collateral) and USDC (debt) prices from the pricer.
-     * Validates that both prices are finite and positive, throwing if not.
+     * Returns the deposit token balance sitting idle inside the vault contract itself.
+     * This balance can offset the required liquidity during withdrawal processing.
      */
-    getAssetPrices(): Promise<{
-        collateralPrice: PriceInfo;
-        debtPrice: PriceInfo;
-    }>;
-    getVesuMultiplyAdapter(): Promise<VesuMultiplyAdapter>;
-    getVesuModifyPositionAdapter(): Promise<VesuModifyPositionAdapter>;
-    getUsdcTransferAdapter(): Promise<TokenTransferAdapter>;
-    getAvnuAdapter(): Promise<AvnuAdapter>;
-    getExtendedAdapter(): Promise<ExtendedAdapter>;
+    getUnusedBalanceVault(): Promise<Web3Number>;
     /**
-     * Creates an ExecutionService wired to this strategy's adapters and config.
-     * Use with `stateManager.solve()` to get a SolveResult, then pass it to
-     * `executionService.execute(solveResult)` for execution.
-     *
-     * @param onExecutionEvent - Optional callback for execution lifecycle events (DB persistence, alerts, etc.)
-     * @param extendedAcceptableSlippageBps - Slippage for Extended limit orders (default: 10 = 0.1%)
-     * @param maxPriceDivergenceBps - Max price divergence between Extended and AVNU (default: 50 = 0.5%)
+     * Returns the current borrow token balance sitting unused in the vault allocator.
+     * This covers borrow token from prior borrow cycles that hasn't been swapped yet.
+     */
+    getUnusedDebt(): Promise<Web3Number>;
+    /**
+     * Returns the LST balance sitting in the vault allocator.
+     * This is non-zero when the previous cycle's request_redeem on the HyperPosition
+     * has been settled — the redeemed LST lands here and is ready to be swapped.
      */
-    createExecutionService(opts?: {
-        onExecutionEvent?: ExecutionCallback;
-        extendedAcceptableSlippageBps?: number;
-        maxPriceDivergenceBps?: number;
-    }): Promise<ExecutionService>;
+    getLstInVaultAllocator(): Promise<Web3Number>;
     /**
-     * Calculates the total Assets Under Management across all adapters.
-     * Aggregates position values from every adapter, converts to the vault's
-     * base asset, and returns the net AUM along with the previous AUM snapshot
-     * and per-position breakdowns.
+     * Simulates depositing `depositAmount` on Vesu and returns the
+     * incremental borrow token that would be borrowed. Needed to size the AVNU swap
+     * call that is batched together with the Vesu call in the same transaction.
      */
+    computeVesuDepositBorrowAmount(depositAmount: Web3Number): Promise<Web3Number>;
+    computeVesuWithdrawDebtDelta(withdrawAmount: Web3Number): Promise<Web3Number>;
+    getPendingHyperAssets(): Promise<Web3Number>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
     getAUM(): Promise<{
         net: SingleTokenInfo;
         prevAum: Web3Number;
         splits: PositionInfo[];
     }>;
     /**
-     * Computes the maximum additional USDC that can be borrowed from Vesu
-     * while keeping the strategy profitable. Uses the Extended funding rate
-     * and Vesu supply APY to derive a break-even borrow APY, then queries
-     * Vesu for the max borrowable amount at that rate.
+     * Get Vesu APYs for collateral and debt positions
+     */
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
+    }>;
+    /**
+     * Get APY from the Hyper LST vault position
+     */
+    getHyperVaultAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    /**
+     * Get APY for unused balance (idle funds in vault allocator)
+     */
+    protected getUnusedBalanceAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    /**
+     * Compute weighted APY from individual APYs, weights, and total AUM
      */
-    getMaxBorrowableAmount(): Promise<Web3Number>;
+    private computeAPY;
     /**
-     * Returns the current health metrics for the strategy:
-     *  [0] Vesu health factor (maxLTV / actualLTV) — higher is safer.
-     *  [1] Extended margin ratio (as percentage) — higher means more margin available.
+     * Calculate net APY from base and reward APYs
      */
-    getVesuHealthFactors(): Promise<number[]>;
+    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], totalWeightUSD: number): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
     /**
-     * Calculates the weighted net APY of the strategy across all positions.
-     * Combines Vesu supply APY (scaled by 0.1 performance fee) and Extended
-     * position APY, weighted by their respective USD values.
-     * Also returns per-position APY splits.
+     * Calculate net APY across all positions (Vesu, Hyper vault, unused balance)
+     * weighted by USD value
      */
     netAPY(): Promise<{
         net: number;
@@ -4436,477 +2817,16 @@ declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySetti
         }[];
     }>;
     /**
-     * Fetches the operator wallet's current holdings for USDC and WBTC,
-     * returning each token's balance and USD value.
+     * Calculate future rewards (e.g. BTCFI rewards) contribution to AUM
+     * Similar to universal-strategy.tsx approach
      */
-    getWalletHoldings(): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }[]>;
+    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
+    getFundManagementCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call[] | null>;
 }
-declare const VesuExtendedTestStrategies: (extendedBackendReadUrl: string, extendedBackendWriteUrl: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number) => IStrategyMetadata<VesuExtendedStrategySettings>[];
-
-declare const AddressesConfig: {
-    readonly tokens: {
-        readonly USDC: {
-            readonly address: "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
-            readonly decimals: 6;
-        };
-        readonly WBTC: {
-            readonly address: "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
-            readonly decimals: 8;
-        };
-    };
-    readonly contracts: {
-        readonly EXTENDED: "0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470";
-        readonly MULTIPLY: "0x07964760e90baa28841ec94714151e03fbc13321797e68a874e88f27c9d58513";
-    };
-    readonly wallet: {
-        readonly address: string;
-    };
-};
-declare const ExtendedConfig: {
-    readonly baseUrl: string;
-    readonly marketName: "BTC-USD";
-    readonly maintenanceMargin: 0.01;
-    readonly precision: 5;
-    readonly fees: number;
-    readonly minPositionSize: 0.0001;
-};
-declare const VesuConfig: {
-    readonly poolId: "0x02eef0c13b10b487ea5916b54c0a7f98ec43fb3048f60fdeedaf5b08f6f88aaf";
-    readonly maxLtv: 0.8428;
-    readonly maxLiquidationRatio: 0.86;
-    readonly targetHealthFactor: number;
-    readonly ekubo: {
-        readonly endpoint: "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}";
-        readonly priceMaxSlippage: number;
-    };
-    readonly avnu: {
-        readonly api: "https://starknet.api.avnu.fi/swap/v2/quotes";
-    };
-    readonly targetLtv: 0.61;
-    readonly minDebtForVesuRebalacing: number;
-};
-declare const AbisConfig: {
-    readonly vesu: {
-        readonly multiply: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-        readonly pool: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-    };
-    readonly extended: {
-        readonly contract: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-    };
-};
-
-/**
- * Function to return formatted amount to BigInt
- * Converts a decimal amount to the proper format for blockchain transactions
- * @param {number} amount - The decimal amount to convert
- * @param {number} fromTokenDecimals - The decimal precision of the token
- * @returns {string} The formatted amount as a hexadecimal string
- */
-declare const returnFormattedAmount: (amount: number, toTokenDecimals: number) => string;
-/**
- * calculates the amount to distribute to Extended and Vesu
- * Determines how much to allocate to each platform based on leverage calculations
- * @param {number} amount - The total amount to distribute
- * @returns {object} Object containing avnu_amount, extended_amount, and extended_leverage
- */
-declare const calculateAmountDistribution: (amountToInvest: number, collateralPrice: number, // in usd
-collateralUnits: Web3Number, // existing collateral in vesu (e.g. BTC)
-extendedExposureUsd: Web3Number) => {
-    vesuAmount: Web3Number;
-    extendedAmount: Web3Number;
-    extendedLeverage: number;
-    vesuLeverage: number;
-};
-/**
- * calculate the amount distribution for withdrawal
- * @param amount - The amount to withdraw
- * @param client - The client
- * @param marketName - The market name
- * @returns {object} Object containing avnu_amount and extended_amount
- */
-declare const calculateAmountDistributionForWithdrawal: (amountInUsdc: Web3Number, collateralPrice: number, collateralUnits: Web3Number, extendedPosition: Position[] | null) => Promise<{
-    vesu_amount: Web3Number;
-    extended_amount: Web3Number;
-    extended_leverage: number;
-    vesu_leverage: number;
-} | null>;
-/**
- * calculate the leverage required for Avnu
- * calculates the optimal leverage for Avnu based on LTV ratios and price drop protection
- * @returns {number} The calculated leverage value
- */
-declare const calculateVesuLeverage: () => number;
-/**
- * calculate leverage for extended
- * calculates the maximum safe leverage for Extended based on maintenance margin and price drop protection
- * @returns {number} The calculated leverage value
- */
-declare const calculateExtendedLevergae: () => number;
-/**
- * calculates the debt amount for leverage operations
- * Determines how much debt to add or remove based on collateral changes and target health factor
- * @param {Web3Number} collateralAmount - Current collateral amount
- * @param {Web3Number} debtAmount - Current debt amount
- * @param {number} debtPrice - Current price of the debt token
- * @param {number} maxLtv - Maximum loan-to-value ratio (default: MAX_LTV_BTC_USDC)
- * @param {number} addedAmount - Amount being added to collateral
- * @param {number} collateralPrice - Current price of the collateral token
- * @param {boolean} isDeposit - Whether this is a deposit (true) or withdrawal (false)
- * @returns {object} Object containing deltadebtAmountUnits and isIncrease flag
- */
-declare const calculateDebtAmount: (collateralAmount: Web3Number, debtAmount: Web3Number, debtPrice: number, maxLtv: number | undefined, addedAmount: Web3Number, // this is in btc
-collateralPrice: number, isDeposit: boolean, targetLtv?: number) => {
-    deltadebtAmountUnits: Web3Number;
-    isIncrease: boolean;
-} | {
-    deltadebtAmountUnits: null;
-    isIncrease: null;
-};
-/**
- * calculate the debt amount to be repaid for withdrawal
- * @param debtAmount in debt units
- * @param collateralAmount in collateral units
- * @param maxLtv in percentage
- * @param withdrawalAmount in collateral units
- * @param collateralPrice in usd
- * @param debtPrice in usd
- * @returns deltadebtAmountUnits in debt units
- *          isIncrease: true if the debt amount is increasing, false if it is decreasing
- */
-declare const calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number | undefined, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, usdcDecimals: number) => {
-    deltadebtAmountUnits: string;
-} | {
-    deltadebtAmountUnits: null;
-};
-/**
- * calculate the amount to deposit on extended when incurring losses
- * @param client - The client
- * @returns The amount to deposit on extended when incurring losses
- */
-declare const calculateAmountDepositOnExtendedWhenIncurringLosses: (client: ExtendedWrapper) => Promise<Web3Number | null>;
-/**
- * calculate the amount of collateral to deposit to maintain the ltv
- * The formula is:
- * ((debt * debtPrice * targetHF) - (collateral * collateralPrice * ltv)) / ltv
- * @param collateralAmount in collateral units
- * @param debtAmount in debt units
- * @param debtPrice in usd
- * @param maxLtv
- * @param collateralPrice in usd
- * @param targetHF
- * @returns deltaCollateralAmountUnits in collateral units
- *          null if there is an error
- */
-declare const calculateWBTCAmountToMaintainLTV: (collateralAmount: Web3Number, debtAmount: Web3Number, debtPrice: number, maxLtv: number | undefined, collateralPrice: number) => {
-    deltaCollateralAmountUnits: Web3Number;
-} | {
-    deltaCollateralAmountUnits: null;
-};
-declare const calculateExposureDelta: (exposure_extended: number, exposure_vesu: number) => number;
-/**
- * calculate the delta percentage between the current btc price and the last btc price
- * @param {number} btcPrice - The current btc price
- * @param {number} lastBtcPrice - The last btc price
- * @returns {number} The delta percentage
- */
-declare const calculateBTCPriceDelta: (btcPrice: number, lastBtcPrice: number) => number;
-declare const calculateVesUPositionSizeGivenExtended: (extendedPositonSize: number, extendedHoldingAmount: Web3Number, collateralAmount: Web3Number, extendedBtcPrice: number) => {
-    vesuAmountInBTC: Web3Number;
-    extendedAmountInBTC: Web3Number;
-};
-/**
- * calculate the debt amount to be repaid to maintain the ltv
- * @param maxLtv - The maximum ltv
- * @param existingVesuCollateral - The existing vesu collateral
- * @param existingVesuDebt - The existing vesu debt
- * @param collateralPrice - The collateral price
- * @param debtPrice - The debt price
- * @param targetHf - The target hf
- * @@dev returns negative to represent debt to be repaid
- * @returns The debt amount to be repaid
- */
-declare const calculateDeltaDebtAmount: (existingVesuCollateral: Web3Number, existingVesuDebt: Web3Number, debtPrice: number, collateralPrice: number) => {
-    deltaDebt: Web3Number;
-    shouldRebalance: boolean;
-};
-declare const calculatePositionToCloseToWithdrawAmount: (extendedBalance: Balance, extendedPositions: Position, amountToWithdraw: Web3Number) => Promise<Web3Number>;
+declare const BoostedxSTRKCarryStrategies: IStrategyMetadata<BoostedxSTRKCarryStrategySettings>[];
 
 /**
  * Filter option definition
@@ -4932,7 +2852,9 @@ declare enum StrategyType {
     UNIVERSAL = "universal",
     HYPER_LST = "hyper-lst",
     VESU_REBALANCE = "vesu-rebalance",
-    SENSEI = "sensei"
+    SENSEI = "sensei",
+    YOLO_VAULT = "yolo-vault",
+    BOOSTEDXSTRKCARRY = "boostedxstrkcarry"
 }
 /**
  * Strategy metadata extracted from IStrategyMetadata
@@ -4983,10 +2905,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<HyperLSTStrategySettings>;
 declare function createVesuRebalanceStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>): VesuRebalance;
 declare function createSenseiStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>): SenseiVault;
@@ -4997,7 +2921,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>): EkuboCLVault | VesuRebalance | SenseiVault | UniversalStrategy<UniversalStrategySettings> | UniversalLstMultiplierStrategy<HyperLSTStrategySettings>;
+declare function createStrategy(type: FactoryStrategyType, config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<any>): EkuboCLVault | VesuRebalance | SenseiVault | YoLoVault | UniversalStrategy<UniversalStrategySettings> | UniversalLstMultiplierStrategy<HyperLSTStrategySettings>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -5204,6 +3128,16 @@ declare class Midas {
     } | number>;
 }
 
+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;
@@ -5356,4 +3290,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { type APYInfo, APYType, AUDIT_URL, AUMTypes, AVNU_EXCHANGE, AVNU_EXCHANGE_FOR_LEGACY_USDC, AVNU_LEGACY_SANITIZER, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, AbisConfig, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, AddressesConfig, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApiResponse, type ApproveCallParams, type AssetOperation, AssetOperationStatus, AssetOperationType, AuditStatus, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuSwapCallParams, AvnuWrapper, type Balance, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type BringLiquidityRoute, CASE_ROUTE_TYPES, type CLVaultStrategySettings, COLLATERAL_PRECISION, type CancelOrderRequest, CaseCategory, CaseId, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, type CrisisBorrowRoute, type CrisisExtendedLeverRoute, CycleType, DEFAULT_TROVES_STRATEGIES_API, type DecreaseLeverParams, Deployer, type DepositParams, type DualActionAmount, type DualTokenInfo, ERC20, EXTENDED_CONTRACT, EXTENDED_SANITIZER, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type ExecutionCallback, type ExecutionConfig, type ExecutionEventMetadata, ExecutionEventType, type ExecutionRoute, ExecutionService, ExitType, ExtendedAdapter, type ExtendedAdapterConfig, type ExtendedApiResponse, type ExtendedBalanceState, ExtendedConfig, type ExtendedLeverRoute, type ExtendedPositionDelta, type ExtendedPositionState, ExtendedSVKVesuStateManager, ExtendedWrapper, type ExtendedWrapperConfig, type FAQ, FactoryStrategyType, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type FundingPayment, type FundingRate, type GenerateCallFn, Global, HealthFactorMath, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, InstantWithdrawalVault, type L2Config, LSTAPRService, LSTPriceType, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type LoggerConfig, type LoggerLevel, type ManageCall, MarginType, type Market, type MarketStats, Midas, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, type OpenOrder, OrderSide, OrderStatus, OrderStatusReason, OrderType, PRICE_ROUTER, type ParsedStarknetCall, PasswordJsonCryptoUtil, type PlacedOrder, type Position, type PositionAPY, type PositionAmount, type PositionHistory, type PositionInfo, PositionSide, PositionTypeAvnuExtended, Pragma, type PriceInfo, Pricer, PricerBase, PricerFromApi, PricerLST, PricerRedis, Protocols, type RealisePnlRoute, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, type RiskFactorConfig, RiskType, type Route, type RouteNode, RouteType, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SettlementSignature, type SignedWithdrawRequest, type SingleActionAmount, type SingleTokenInfo, SolveBudget, type SolveCase, type SolveCaseEntry, type SolveResult, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, type StarkDebuggingOrderAmounts, type StarkSettlement, StarknetCallParser, type StarknetCallParserOptions, type StateManagerConfig, Store, type StoreConfig, type StrategyAlert, type StrategyCapabilities, type StrategyFilterMetadata, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, SvkTrovesAdapter, type SvkTrovesAdapterConfig, type Swap, type SwapInfo, type SwapPriceInfo, type SwapRoute, TRANSFER_SANITIZER, TelegramGroupNotif, TelegramNotif, TimeInForce, type TokenAmount, type TokenBalance, type TokenInfo, TokenMarketData, TokenTransferAdapter, type TokenTransferAdapterConfig, type TradingConfig, type TransactionMetadata, type TransactionResult, type TransferRoute, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, type UpdateLeverageRequest, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VaultType, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, VesuConfig, type VesuDebtRoute, type VesuDefiSpringRewardsCallParams, type VesuDepositParams, VesuExtendedMultiplierStrategy, type VesuExtendedStrategySettings, VesuExtendedTestStrategies, type VesuModifyDelegationCallParams, VesuModifyPositionAdapter, type VesuModifyPositionAdapterConfig, type VesuModifyPositionCallParams, type VesuModifyPositionDepositParams, type VesuModifyPositionWithdrawParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, type VesuMultiplyRoute, type VesuPoolDelta, VesuPoolMetadata, type VesuPoolState, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, type VesuWithdrawParams, type WaitRoute, Web3Number, type WithdrawParams, type WithdrawRequest, ZkLend, _riskFactor, assert, buildStrategyRegistry, calculateAmountDepositOnExtendedWhenIncurringLosses, calculateAmountDistribution, calculateAmountDistributionForWithdrawal, calculateBTCPriceDelta, calculateDebtAmount, calculateDebtReductionAmountForWithdrawal, calculateDeltaDebtAmount, calculateExposureDelta, calculateExtendedLevergae, calculatePositionToCloseToWithdrawAmount, calculateVesUPositionSizeGivenExtended, calculateVesuLeverage, calculateWBTCAmountToMaintainLTV, configureLogger, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createSolveBudgetFromRawState, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getAllStrategyTags, getContractDetails, getDefaultStoreConfig, getFAQs, getFilterMetadata, getInvestmentSteps, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTagDesciption, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, returnFormattedAmount, routeSummary, toAmountsInfo, toBigInt };
+export { type APYInfo, APYType, AUDIT_URL, AUMTypes, AVNU_EXCHANGE, AVNU_EXCHANGE_FOR_LEGACY_USDC, AVNU_LEGACY_SANITIZER, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuDepositParams, type AvnuSwapCallParams, type AvnuWithdrawParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, BoostedxSTRKCarryStrategies, BoostedxSTRKCarryStrategy, type BoostedxSTRKCarryStrategySettings, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, DEFAULT_TROVES_STRATEGIES_API, type DecreaseLeverParams, Deployer, type DepositParams, type DualActionAmount, type DualTokenInfo, ERC20, EXTENDED_CONTRACT, EXTENDED_SANITIZER, 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, HealthFactorMath, 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 LoggerConfig, type LoggerLevel, type ManageCall, MarginType, Midas, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, PRICE_ROUTER, type ParsedStarknetCall, PasswordJsonCryptoUtil, type PositionAPY, type PositionAmount, type PositionInfo, PositionTypeAvnuExtended, Pragma, type PriceInfo, Pricer, PricerBase, 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, SVK_SIMPLE_SANITIZER, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, StarknetCallParser, type StarknetCallParserOptions, Store, type StoreConfig, type StrategyAlert, type StrategyApyHistoryUIConfig, type StrategyCapabilities, type StrategyFilterMetadata, type StrategyInputMode, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, SvkTrovesAdapter, type SvkTrovesAdapterConfig, type Swap, type SwapInfo, type SwapPriceInfo, TRANSFER_SANITIZER, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, TokenMarketData, TokenTransferAdapter, type TokenTransferAdapterConfig, UNIVERSAL_ADAPTER_IDS, 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 VesuDepositParams, type VesuModifyDelegationCallParams, VesuModifyPositionAdapter, type VesuModifyPositionAdapterConfig, type VesuModifyPositionCallParams, type VesuModifyPositionDepositParams, type VesuModifyPositionWithdrawParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, VesuPoolMetadata, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, type VesuWithdrawParams, Web3Number, type WithdrawParams, YoLoVault, type YoloSettings, type YoloSpendingLevel, type YoloVaultSettings, type YoloVaultStatus, YoloVaultStrategies, ZkLend, _riskFactor, assert, buildStrategyRegistry, configureLogger, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, createYoloVaultStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getAllStrategyTags, getContractDetails, getDefaultStoreConfig, getFAQs, getFilterMetadata, getInvestmentSteps, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTagDesciption, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };