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

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Contract, Call, Account, CairoCustomEnum, Uint256, RawArgs } from 'starknet';
+import { RpcProvider, BlockIdentifier, Call, Contract, Uint256, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import BigNumber from 'bignumber.js';
 import React, { ReactNode } from 'react';
+import { Quote, AvnuOptions } from '@avnu/avnu-sdk';
 import { HexString, BytesLike } from '@ericnordelo/strk-merkle-tree/dist/bytes';
 import { MultiProof } from '@ericnordelo/strk-merkle-tree/dist/core';
 import { MerkleTreeImpl, MerkleTreeData } from '@ericnordelo/strk-merkle-tree/dist/merkletree';
 import { MerkleTreeOptions } from '@ericnordelo/strk-merkle-tree/dist/options';
 import { ValueType } from '@ericnordelo/strk-merkle-tree/dist/serde';
-import { Quote, AvnuOptions } from '@avnu/avnu-sdk';
 import TelegramBot from 'node-telegram-bot-api';
 
 declare class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
@@ -27,10 +27,12 @@ declare class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
     minimum(value: string | number | T): T;
     maximum(value: string | number | T): T;
     abs(): T;
+    toFixedRoundDown(dp?: number): string;
     toI129(): {
         mag: bigint;
         sign: 0 | 1;
     };
+    toUint256(): starknet.Uint256;
 }
 
 declare class Web3Number extends _Web3Number<Web3Number> {
@@ -54,6 +56,33 @@ declare class ContractAddr {
     shortString(left?: number, right?: number): string;
 }
 
+declare const customInspectSymbol: unique symbol;
+declare class MyNumber {
+    bigNumber: BigNumber;
+    decimals: number;
+    constructor(bigNumber: string, decimals: number);
+    static fromEther(num: string, decimals: number): MyNumber;
+    static fromZero(): MyNumber;
+    toString(): string;
+    toEtherStr(): string;
+    toFixedStr(decimals: number): string;
+    toEtherToFixedDecimals(decimals: number): string;
+    isZero(): boolean;
+    /**
+     *
+     * @param amountEther in token terms without decimal e.g. 1 for 1 STRK
+     * @param command BigNumber compare funds. e.g. gte, gt, lt
+     * @returns
+     * @dev Add more commands as needed
+     */
+    compare(amountEther: string, command: "gte" | "gt" | "lt"): boolean;
+    operate(command: "div" | "plus" | "mul", value: string | number): MyNumber;
+    subtract(value: MyNumber): MyNumber;
+    static min(a: MyNumber, b: MyNumber): MyNumber;
+    static max(a: MyNumber, b: MyNumber): MyNumber;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+}
+
 declare enum RiskType {
     MARKET_RISK = "Market Risk",
     IMPERMANENT_LOSS = "Impermanent Loss Risk",
@@ -97,6 +126,56 @@ interface IProtocol {
     name: string;
     logo: string;
 }
+declare enum StrategyTag {
+    META_VAULT = "Meta Vaults",
+    LEVERED = "Maxx",
+    AUTOMATED_LP = "Ekubo",
+    BTC = "BTC"
+}
+declare enum VaultType {
+    LOOPING = "Looping",
+    META_VAULT = "Meta Vault",
+    DELTA_NEUTRAL = "Delta Neutral",
+    AUTOMATED_LP = "Automated LP"
+}
+declare enum AuditStatus {
+    AUDITED = "Audited",
+    NOT_AUDITED = "Not Audited"
+}
+declare enum SourceCodeType {
+    OPEN_SOURCE = "Open Source",
+    CLOSED_SOURCE = "Closed Source"
+}
+declare enum AccessControlType {
+    MULTISIG_ACCOUNT = "Multisig Account",
+    STANDARD_ACCOUNT = "Standard Account"
+}
+declare enum InstantWithdrawalVault {
+    YES = "Yes",
+    NO = "No"
+}
+interface SourceCodeInfo {
+    type: SourceCodeType;
+    contractLink: string;
+}
+interface AccessControlInfo {
+    type: AccessControlType;
+    addresses: ContractAddr[];
+    timeLock: string;
+}
+interface SecurityMetadata {
+    auditStatus: AuditStatus;
+    sourceCode: SourceCodeInfo;
+    accessControl: AccessControlInfo;
+}
+interface RedemptionInfo {
+    instantWithdrawalVault: InstantWithdrawalVault;
+    redemptionsInfo: {
+        title: string;
+        description: string;
+    }[];
+    alerts: StrategyAlert[];
+}
 declare enum FlowChartColors {
     Green = "purple",
     Blue = "#35484f",
@@ -106,26 +185,62 @@ interface FAQ {
     question: string | React.ReactNode;
     answer: string | React.ReactNode;
 }
+declare enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    DEPRECATED = "Deprecated",// active but not recommended
+    RETIRED = "Retired",// not active anymore
+    HOT = "Hot & New \uD83D\uDD25"
+}
+interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+interface StrategySettings {
+    maxTVL?: Web3Number;
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
+}
 /**
  * @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.
+ * @property security - Security-related metadata including audit status, source code information, and access control details.
+ * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 interface IStrategyMetadata<T> {
+    id: string;
     name: string;
     description: string | React.ReactNode;
     address: ContractAddr;
     launchBlock: number;
     type: "ERC4626" | "ERC721" | "Other";
+    vaultType: {
+        type: VaultType;
+        description: string;
+    };
     depositTokens: TokenInfo[];
     protocols: IProtocol[];
     auditUrl?: string;
-    maxTVL: Web3Number;
     risk: {
         riskFactor: RiskFactor[];
         netRisk: number;
         notARisks: RiskType[];
     };
     apyMethodology?: string;
+    realizedAPYMethodology?: string;
     additionalInfo: T;
     contractDetails: {
         address: ContractAddr;
@@ -145,6 +260,36 @@ interface IStrategyMetadata<T> {
         logo: string;
     };
     isPreview?: boolean;
+    tags?: StrategyTag[];
+    security: SecurityMetadata;
+    redemptionInfo: RedemptionInfo;
+    usualTimeToEarnings: null | string;
+    usualTimeToEarningsDescription: null | string;
+    discontinuationInfo?: {
+        date?: Date;
+        reason?: React.ReactNode | string;
+        info?: React.ReactNode | string;
+    };
+    settings?: StrategySettings;
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: {
+                name: string;
+                logo: string;
+            };
+            pool?: {
+                name: string;
+                logos?: string[];
+            };
+            apr?: number;
+            borrow?: {
+                apr?: number;
+            };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -157,6 +302,8 @@ interface IInvestmentFlow {
     style?: any;
 }
 declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
+declare const getStrategyTagDesciption: (tag: StrategyTag) => string;
+declare const getAllStrategyTags: () => StrategyTag[];
 declare const getRiskExplaination: (riskType: RiskType) => "The risk of the market moving against the position." | "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them." | "The risk of losing funds due to the position being liquidated." | "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position." | "The risk of the oracle being manipulated or incorrect." | "The risk of the smart contract being vulnerable to attacks." | "The risk of technical issues e.g. backend failure." | "The risk of the counterparty defaulting e.g. bad debt on lending platforms." | "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
 declare const getRiskColor: (risk: RiskFactor) => "light_green_2" | "yellow" | "red";
 declare const getNoRiskTags: (risks: RiskFactor[]) => RiskType[];
@@ -172,6 +319,27 @@ interface VaultPosition {
     remarks: string;
     protocol: IProtocol;
 }
+interface AmountInfo {
+    amount: Web3Number;
+    usdValue: number;
+    tokenInfo: TokenInfo;
+}
+interface AmountsInfo {
+    usdValue: number;
+    amounts: AmountInfo[];
+}
+/**
+ * Strategy capabilities interface
+ * Describes what optional methods a strategy instance supports
+ */
+interface StrategyCapabilities {
+    hasMatchInputAmounts: boolean;
+    hasNetAPY: boolean;
+    hasGetInvestmentFlows: boolean;
+    hasGetPendingRewards: boolean;
+    hasHarvest: boolean;
+    hasRebalance: boolean;
+}
 declare const Protocols: {
     NONE: IProtocol;
     VESU: IProtocol;
@@ -245,7 +413,7 @@ declare class Pricer extends PricerBase {
     refreshInterval: number;
     staleTime: number;
     protected methodToUse: {
-        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap';
+        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu';
     };
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -258,11 +426,12 @@ declare class Pricer extends PricerBase {
     start(): void;
     isStale(timestamp: Date, tokenName: string): boolean;
     assertNotStale(timestamp: Date, tokenName: string): void;
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
     protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
     _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
     _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
+    _getAvnuPrice(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
     _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
 }
 
@@ -270,7 +439,7 @@ declare abstract class PricerBase {
     readonly config: IConfig;
     readonly tokens: TokenInfo[];
     constructor(config: IConfig, tokens: TokenInfo[]);
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
 }
 
 interface CacheData$1 {
@@ -285,291 +454,314 @@ declare class CacheClass {
     isCacheValid(key: string): boolean;
 }
 
-interface LeveledLogMethod {
-    (message: string, ...meta: any[]): void;
-    (message: any): void;
-}
-interface MyLogger {
-    error: LeveledLogMethod;
-    warn: LeveledLogMethod;
-    info: LeveledLogMethod;
-    verbose: LeveledLogMethod;
-    debug: LeveledLogMethod;
+interface HarvestInfo {
+    rewardsContract: ContractAddr;
+    token: ContractAddr;
+    startDate: Date;
+    endDate: Date;
+    claim: {
+        id: number;
+        amount: Web3Number;
+        claimee: ContractAddr;
+    };
+    actualReward: Web3Number;
+    proof: string[];
 }
-declare const logger: MyLogger;
 
-interface LeafData {
-    id: bigint;
-    readableId: string;
-    data: bigint[];
-}
-interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
-    format: 'standard-v1';
-    leafEncoding: ValueType[];
+interface SingleActionAmount {
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
 }
-declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
-    protected readonly tree: HexString[];
-    protected readonly values: StandardMerkleTreeData<LeafData>['values'];
-    protected readonly leafEncoding: ValueType[];
-    protected constructor(tree: HexString[], values: StandardMerkleTreeData<LeafData>['values'], leafEncoding: ValueType[]);
-    static of(values: LeafData[], leafEncoding?: ValueType[], options?: MerkleTreeOptions): StandardMerkleTree;
-    static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean;
-    static verifyMultiProof<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], multiproof: MultiProof<BytesLike, T>): boolean;
-    dump(): StandardMerkleTreeData<LeafData>;
+interface SingleTokenInfo extends SingleActionAmount {
+    usdValue: number;
 }
-
-type RequiredFields<T> = {
-    [K in keyof T]-?: T[K];
-};
-type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
-}[keyof T];
-declare function assert(condition: boolean, message: string): void;
-declare function getTrovesEndpoint(): string;
-
-interface ManageCall {
-    sanitizer: ContractAddr;
-    call: {
-        contractAddress: ContractAddr;
-        selector: string;
-        calldata: bigint[];
-    };
+interface APYInfo {
+    net: number;
+    splits: {
+        apy: number;
+        id: string;
+    }[];
 }
-interface DepositParams {
-    amount: Web3Number;
+interface DualActionAmount {
+    token0: SingleActionAmount;
+    token1: SingleActionAmount;
 }
-interface WithdrawParams {
-    amount: Web3Number;
+interface DualTokenInfo {
+    usdValue: number;
+    token0: SingleTokenInfo;
+    token1: SingleTokenInfo;
 }
-type GenerateCallFn<T> = (params: T) => Promise<ManageCall[]>;
-type AdapterLeafType<T> = {
-    leaves: LeafData[];
-    callConstructor: GenerateCallFn<T>;
-};
-type LeafAdapterFn<T> = () => AdapterLeafType<T>;
-declare enum APYType {
-    BASE = "base",
-    REWARD = "reward",
-    LST = "lst"
+interface NetAPYSplit {
+    apy: number;
+    id: string;
 }
-interface SupportedPosition {
-    asset: TokenInfo;
-    isDebt: boolean;
+interface NetAPYDetails {
+    net: number;
+    splits: NetAPYSplit[];
 }
-interface BaseAdapterConfig {
-    baseToken: TokenInfo;
-    supportedPositions: SupportedPosition[];
-    networkConfig: IConfig;
-    pricer: PricerBase;
-    vaultAllocator: ContractAddr;
-    vaultAddress: ContractAddr;
+interface CacheData {
+    timestamp: number;
+    ttl: number;
+    data: any;
 }
-type PositionAPY = {
-    apy: number;
-    type: APYType;
-};
-type PositionInfo = {
-    tokenInfo: TokenInfo;
-    amount: Web3Number;
-    usdValue: number;
-    remarks: string;
-    apy: PositionAPY;
-    protocol: IProtocol;
-};
-type PositionAmount = {
-    amount: Web3Number;
-    remarks: string;
-};
-declare abstract class BaseAdapter<DepositParams, WithdrawParams> extends CacheClass {
-    readonly name: string;
-    readonly config: BaseAdapterConfig;
-    readonly protocol: IProtocol;
-    constructor(config: BaseAdapterConfig, name: string, protocol: IProtocol);
+declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
+    readonly config: IConfig;
+    readonly cache: Map<string, CacheData>;
+    constructor(config: IConfig);
+    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[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | NetAPYDetails>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
     /**
-     * Loop through all supported positions and return amount, usd value, remarks and apy for each
+     * Calculate lifetime earnings for a user based on provided data from client
+     * Formula: lifetimeEarnings = currentValue + totalWithdrawals - totalDeposits
+     *
+     * @param userTVL - The user's current TVL (SingleTokenInfo with amount, usdValue, tokenInfo)
+     * @param investmentFlows - Array of investment flow transactions from client
+     * @returns Object containing lifetime earnings, current value, and total deposits/withdrawals
      */
-    getPositions(): Promise<PositionInfo[]>;
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): {
+        tokenInfo: SingleTokenInfo;
+        lifetimeEarnings: Web3Number;
+        currentValue: Web3Number;
+        totalDeposits: Web3Number;
+        totalWithdrawals: Web3Number;
+    };
+}
+
+/**
+ * TokenMarketData class that combines LST APR and Midas modules
+ * to provide unified APY, price, and TVL functions for tokens
+ */
+declare class TokenMarketData {
+    private pricer;
+    private config;
+    constructor(pricer: PricerBase, config: IConfig);
     /**
-     * Implemented by child adapters to compute APY for a given supported position
+     * Get APY for a token
+     * - If it's an LST token, returns LST APY
+     * - If it's a Midas token, returns Midas APY
+     * - Otherwise returns 0
+     * @param tokenInfo The token to get APY for
+     * @returns APY in absolute terms (not percentage)
      */
-    protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    getAPY(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to fetch amount for a given supported position
+     * Get price for a token using the pricer module
+     * @param tokenInfo The token to get price for
+     * @returns Price as a number
+     * @throws Error if price is 0 or unavailable
      */
-    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    getPrice(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to calculate maximum deposit positions
-     * @param amount Optional amount in baseToken to deposit
+     * Get true price for a token
+     * - For LST tokens: Uses convert_to_assets to get true exchange rate
+     * - For Midas tokens: Uses Midas price API
+     * - For other tokens: Falls back to regular pricer
+     * @param tokenInfo The token to get true price for
+     * @returns True price as a number
+     * @throws Error if price is 0 or unavailable
      */
-    abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    getTruePrice(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to calculate maximum withdraw positions
+     * Get TVL for a token
+     * - If it's a Midas token, returns Midas TVL data
+     * - Otherwise returns 0
+     * @param tokenInfo The token to get TVL for
+     * @returns TVL as SingleTokenInfo or 0
      */
-    abstract maxWithdraw(): Promise<PositionInfo>;
+    getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo>;
     /**
-     * Uses pricer to convert an amount of an asset to USD value
+     * Check if a token is supported for APY data
+     * @param tokenInfo The token to check
+     * @returns True if the token has APY data available
      */
-    protected getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number>;
-    protected constructSimpleLeafData(params: {
-        id: string;
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-    }, sanitizer?: ContractAddr): LeafData;
+    isAPYSupported(tokenInfo: TokenInfo): boolean;
     /**
-     * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+     * Check if a token is supported for TVL data
+     * @param tokenInfo The token to check
+     * @returns True if the token has TVL data available
      */
-    protected abstract _getDepositLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
+    isTVLSupported(tokenInfo: TokenInfo): boolean;
+}
+
+declare class Pragma extends PricerBase {
+    contractAddr: string;
+    readonly contract: Contract;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    getPrice(tokenAddr: string, blockIdentifier?: BlockIdentifier): Promise<PriceInfo>;
+}
+
+declare class ZkLend extends ILending implements ILending {
+    readonly pricer: Pricer;
+    static readonly POOLS_URL = "https://app.zklend.com/api/pools";
+    private POSITION_URL;
+    constructor(config: IConfig, pricer: Pricer);
+    init(): Promise<void>;
     /**
-     * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
-     */
-    protected abstract _getWithdrawLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    /**
-     * Returns deposit leaf adapter using configured proof id
+     * @description Get the health factor of the user for given lending and debt tokens
+     * @param lending_tokens
+     * @param debt_tokens
+     * @param user
+     * @returns hf (e.g. returns 1.5 for 150% health factor)
      */
-    getDepositLeaf(): AdapterLeafType<DepositParams>;
+    get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number>;
     /**
-     * Returns withdraw leaf adapter using configured proof id
+     * @description Get the health factor of the user
+     * - Considers all tokens for collateral and debt
      */
-    getWithdrawLeaf(): AdapterLeafType<WithdrawParams>;
+    get_health_factor(user: ContractAddr): Promise<number>;
+    getPositionsSummary(user: ContractAddr): Promise<{
+        collateralUSD: number;
+        debtUSD: number;
+    }>;
     /**
-     * Implementor must provide deposit call
-     * @param params
+     * @description Get the token-wise collateral and debt positions of the user
+     * @param user Contract address of the user
+     * @returns Promise<ILendingPosition[]>
      */
-    abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
+}
+
+declare class PricerFromApi extends PricerBase {
+    private apolloClient;
+    private pragma;
+    private ekuboPricer;
+    private readonly PRAGMA_SUPPORTED_TOKENS;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
+    getPriceFromMyAPI(tokenSymbol: string): Promise<{
+        price: number;
+        timestamp: Date;
+    }>;
     /**
-     * Implementor must provide withdraw call
-     * @param params
+     * Fetches historical price for a token at a specific block number
+     * @param tokenSymbol - The token symbol to get price for
+     * @param blockNumber - The block number to query
+     * @returns PriceInfo with price at the closest block <= blockNumber
      */
-    abstract getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    getProofs<T>(isDeposit: boolean, tree: StandardMerkleTree): {
-        proofs: string[][];
-        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
-    };
-    getNetAPY(): Promise<number>;
-    abstract getHealthFactor(): Promise<number>;
+    getHistoricalPrice(tokenSymbol: string, blockNumber: BlockIdentifier): Promise<PriceInfo>;
 }
 
-interface FlashloanCallParams {
-    amount: Web3Number;
-    data: bigint[];
-}
-interface ApproveCallParams {
-    amount: Web3Number;
+declare class ERC20 {
+    readonly config: IConfig;
+    constructor(config: IConfig);
+    contract(addr: string | ContractAddr): Contract;
+    balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
+    allowance(token: string | ContractAddr, owner: string | ContractAddr, spender: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
+    transfer(token: string | ContractAddr, to: string | ContractAddr, amount: Web3Number): starknet.Call;
+    transferFrom(token: string | ContractAddr, from: string | ContractAddr, to: string | ContractAddr, amount: Web3Number): starknet.Call;
+    approve(token: string | ContractAddr, spender: string | ContractAddr, amount: Web3Number): starknet.Call;
 }
-interface AvnuSwapCallParams {
-    props: SwapInfo;
+
+interface Route {
+    token_from: string;
+    token_to: string;
+    exchange_address: string;
+    percent: number;
+    additional_swap_params: string[];
 }
-interface CommonAdapterConfig {
-    id: string;
-    vaultAddress: ContractAddr;
-    vaultAllocator: ContractAddr;
-    manager: ContractAddr;
-    asset: ContractAddr;
+interface SwapInfo {
+    token_from_address: string;
+    token_from_amount: Uint256;
+    token_to_address: string;
+    token_to_amount: Uint256;
+    token_to_min_amount: Uint256;
+    beneficiary: string;
+    integrator_fee_amount_bps: number;
+    integrator_fee_recipient: string;
+    routes: Route[];
 }
-declare class CommonAdapter {
-    config: CommonAdapterConfig;
-    constructor(config: CommonAdapterConfig);
-    protected constructSimpleLeafData(params: {
-        id: string;
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-    }, sanitizer?: ContractAddr): LeafData;
-    getFlashloanAdapter(): Promise<AdapterLeafType<FlashloanCallParams>>;
-    getFlashloanCall(params: FlashloanCallParams): Promise<ManageCall[]>;
-    getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams>;
-    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
-    getApproveCall(token: ContractAddr, spender: ContractAddr): (params: ApproveCallParams) => Promise<{
-        sanitizer: ContractAddr;
-        call: {
-            contractAddress: ContractAddr;
-            selector: string;
-            calldata: bigint[];
-        };
-    }[]>;
-    getBringLiquidityCall(): GenerateCallFn<ApproveCallParams>;
+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[][]>;
 }
 
-interface HarvestInfo {
-    rewardsContract: ContractAddr;
-    token: ContractAddr;
-    startDate: Date;
-    endDate: Date;
-    claim: {
-        id: number;
-        amount: Web3Number;
-        claimee: ContractAddr;
+declare class AutoCompounderSTRK {
+    readonly config: IConfig;
+    readonly addr: ContractAddr;
+    readonly pricer: Pricer;
+    private initialized;
+    contract: Contract | null;
+    readonly metadata: {
+        decimals: number;
+        underlying: {
+            address: ContractAddr;
+            name: string;
+            symbol: string;
+        };
+        name: string;
     };
-    actualReward: Web3Number;
-    proof: string[];
+    constructor(config: IConfig, pricer: Pricer);
+    init(): Promise<void>;
+    waitForInitilisation(): Promise<void>;
+    /** Returns shares of user */
+    balanceOf(user: ContractAddr): Promise<Web3Number>;
+    /** Returns underlying assets of user */
+    balanceOfUnderlying(user: ContractAddr): Promise<Web3Number>;
+    /** Returns usd value of assets */
+    usdBalanceOfUnderlying(user: ContractAddr): Promise<{
+        usd: Web3Number;
+        assets: Web3Number;
+    }>;
 }
 
-interface EkuboPoolKey {
-    token0: ContractAddr;
-    token1: ContractAddr;
-    fee: string;
-    tick_spacing: string;
-    extension: string;
+interface PoolProps {
+    pool_id: ContractAddr;
+    max_weight: number;
+    v_token: ContractAddr;
 }
-interface EkuboBounds {
-    lowerTick: bigint;
-    upperTick: bigint;
+interface Change {
+    pool_id: ContractAddr;
+    changeAmt: Web3Number;
+    finalAmt: Web3Number;
+    isDeposit: boolean;
 }
-interface FeeHistory {
-    date: string;
-    tokenInfo: TokenInfo;
+interface VesuRebalanceSettings {
+    feeBps: number;
+}
+interface PoolInfoFull {
+    pool_id: ContractAddr;
+    pool_name: string | undefined;
+    max_weight: number;
+    current_weight: number;
+    v_token: ContractAddr;
     amount: Web3Number;
+    usdValue: Web3Number;
+    APY: {
+        baseApy: number;
+        defiSpringApy: number;
+        netApy: number;
+    };
+    currentUtilization: number;
+    maxUtilization: number;
 }
 /**
- * Settings for the CLVaultStrategy
- *
- * @property newBounds - The new bounds for the strategy
- * @property newBounds.lower - relative to the current tick
- * @property newBounds.upper - relative to the current tick
+ * Represents a VesuRebalance strategy.
+ * This class implements an automated rebalancing strategy for Vesu pools,
+ * managing deposits and withdrawals while optimizing yield through STRK rewards.
  */
-interface CLVaultStrategySettings {
-    newBounds: {
-        lower: number;
-        upper: number;
-    } | string;
-    lstContract?: ContractAddr;
-    truePrice?: number;
-    feeBps: number;
-    rebalanceConditions: {
-        minWaitHours: number;
-        direction: "any" | "uponly";
-        customShouldRebalance: (currentPoolPrice: number) => Promise<boolean>;
-    };
-    quoteAsset: TokenInfo;
-}
-declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount> {
+declare class VesuRebalance 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<CLVaultStrategySettings>;
+    readonly metadata: IStrategyMetadata<VesuRebalanceSettings>;
     /** Contract instance for interacting with the strategy */
     readonly contract: Contract;
     readonly BASE_WEIGHT = 10000;
-    readonly ekuboPositionsContract: Contract;
-    readonly ekuboMathContract: Contract;
-    readonly lstContract: Contract | null;
-    poolKey: EkuboPoolKey | undefined;
-    readonly avnu: AvnuWrapper;
     /**
      * Creates a new VesuRebalance strategy instance.
      * @param config - Configuration object containing provider and other settings
@@ -577,40 +769,280 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param metadata - Strategy metadata including deposit tokens and address
      * @throws {Error} If more than one deposit token is specified
      */
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>);
-    matchInputAmounts(amountInfo: DualActionAmount): Promise<DualActionAmount>;
-    /** Returns minimum amounts give given two amounts based on what can be added for liq */
-    getMinDepositAmounts(amountInfo: DualActionAmount): Promise<DualActionAmount>;
-    depositCall(amountInfo: DualActionAmount, receiver: ContractAddr): Promise<Call[]>;
-    tokensToShares(amountInfo: DualActionAmount): Promise<Web3Number>;
-    withdrawCall(amountInfo: DualActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    rebalanceCall(newBounds: EkuboBounds, swapParams: SwapInfo): Call[];
-    handleUnusedCall(swapParams: SwapInfo): Call[];
-    handleFeesCall(): Call[];
-    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m'): Promise<{
-        summary: DualTokenInfo;
-        history: FeeHistory[];
-    }>;
-    netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
-    feeBasedAPY(timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>);
     /**
-     * Calculates assets before and now in a given token of TVL per share to observe growth
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * Creates a deposit call to the strategy contract.
+     * @param assets - Amount of assets to deposit
+     * @param receiver - Address that will receive the strategy tokens
+     * @returns Populated contract call for deposit
      */
-    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<APYInfo>;
-    getHarvestRewardShares(fromBlock: number, toBlock: number): Promise<Web3Number>;
-    balanceOf(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<Web3Number>;
-    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
-    _getTVL(blockIdentifier?: BlockIdentifier): Promise<{
-        amount0: Web3Number;
-        amount1: Web3Number;
-    }>;
-    totalSupply(blockIdentifier?: BlockIdentifier): Promise<Web3Number>;
-    assertValidDepositTokens(poolKey: EkuboPoolKey): void;
-    getTVL(blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
-    getUncollectedFees(): Promise<DualTokenInfo>;
-    getCurrentNFTID(): Promise<number>;
-    truePrice(): Promise<number>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<starknet.Call[]>;
+    /**
+     * Creates a withdrawal call to the strategy contract.
+     * @param assets - Amount of assets to withdraw
+     * @param receiver - Address that will receive the withdrawn assets
+     * @param owner - Address that owns the strategy tokens
+     * @returns Populated contract call for withdrawal
+     */
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<starknet.Call[]>;
+    /**
+     * Returns the underlying asset token of the strategy.
+     * @returns The deposit token supported by this strategy
+     */
+    asset(): TokenInfo;
+    /**
+     * Returns the number of decimals used by the strategy token.
+     * @returns Number of decimals (same as the underlying token)
+     */
+    decimals(): number;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
+    /**
+     * 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;
+    }>;
+    static getAllPossibleVerifiedPools(asset: ContractAddr): Promise<any>;
+    getPoolInfo(p: PoolProps, pools: any[], vesuPositions: any[], totalAssets: Web3Number, isErrorPositionsAPI: boolean, isErrorPoolsAPI: boolean): Promise<{
+        pool_id: ContractAddr;
+        pool_name: any;
+        max_weight: number;
+        current_weight: number;
+        v_token: ContractAddr;
+        amount: Web3Number;
+        usdValue: Web3Number;
+        APY: {
+            baseApy: number;
+            defiSpringApy: number;
+            netApy: number;
+        };
+        currentUtilization: number;
+        maxUtilization: number;
+    }>;
+    /**
+     * Retrieves the list of allowed pools and their detailed information from multiple sources:
+     * 1. Contract's allowed pools
+     * 2. Vesu positions API for current positions
+     * 3. Vesu pools API for APY and utilization data
+     *
+     * @returns {Promise<{
+     *   data: Array<PoolInfoFull>,
+     *   isErrorPositionsAPI: boolean
+     * }>} Object containing:
+     *   - data: Array of pool information including IDs, weights, amounts, APYs and utilization
+     *   - isErrorPositionsAPI: Boolean indicating if there was an error fetching position data
+     */
+    getPools(): Promise<{
+        data: {
+            pool_id: ContractAddr;
+            pool_name: any;
+            max_weight: number;
+            current_weight: number;
+            v_token: ContractAddr;
+            amount: Web3Number;
+            usdValue: Web3Number;
+            APY: {
+                baseApy: number;
+                defiSpringApy: number;
+                netApy: number;
+            };
+            currentUtilization: number;
+            maxUtilization: number;
+        }[];
+        isErrorPositionsAPI: boolean;
+        isErrorPoolsAPI: boolean;
+        isError: boolean;
+    }>;
+    getVesuPools(retry?: number): Promise<{
+        pools: any[];
+        isErrorPoolsAPI: boolean;
+    }>;
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    netAPY(): Promise<APYInfo>;
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    netAPYGivenPools(pools: PoolInfoFull[]): Promise<number>;
+    /**
+     * Calculates optimal position changes to maximize APY while respecting max weights.
+     * The algorithm:
+     * 1. Sorts pools by APY (highest first)
+     * 2. Calculates target amounts based on max weights
+     * 3. For each pool that needs more funds:
+     *    - Takes funds from lowest APY pools that are over their target
+     * 4. Validates that total assets remain constant
+     *
+     * @returns {Promise<{
+     *   changes: Change[],
+     *   finalPools: PoolInfoFull[],
+     *   isAnyPoolOverMaxWeight: boolean
+     * }>} Object containing:
+     *   - changes: Array of position changes
+     *   - finalPools: Array of pool information after rebalance
+     * @throws Error if rebalance is not possible while maintaining constraints
+     */
+    getRebalancedPositions(_pools?: PoolInfoFull[]): Promise<{
+        changes: never[];
+        finalPools: never[];
+        isAnyPoolOverMaxWeight?: undefined;
+    } | {
+        changes: Change[];
+        finalPools: PoolInfoFull[];
+        isAnyPoolOverMaxWeight: boolean;
+    }>;
+    /**
+     * Creates a rebalance Call object for the strategy contract
+     * @param pools - Array of pool information including IDs, weights, amounts, APYs and utilization
+     * @returns Populated contract call for rebalance
+     */
+    getRebalanceCall(pools: Awaited<ReturnType<typeof this.getRebalancedPositions>>["changes"], isOverWeightAdjustment: boolean): Promise<starknet.Call | null>;
+    getInvestmentFlows(pools: PoolInfoFull[]): Promise<IInvestmentFlow[]>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    harvest(acc: Account): Promise<starknet.Call[]>;
+    /**
+     * Calculates the fees deducted in different vTokens based on the current and previous state.
+     * @param previousTotalSupply - The total supply of the strategy token before the transaction
+     * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
+     */
+    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
+        vToken: ContractAddr;
+        fee: Web3Number;
+    }>>;
+}
+/**
+ * Represents the Vesu Rebalance Strategies.
+ */
+declare const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[];
+
+interface EkuboPoolKey {
+    token0: ContractAddr;
+    token1: ContractAddr;
+    fee: string;
+    tick_spacing: string;
+    extension: string;
+}
+interface EkuboBounds {
+    lowerTick: bigint;
+    upperTick: bigint;
+}
+interface FeeHistory {
+    date: string;
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
+}
+/**
+ * Settings for the CLVaultStrategy
+ *
+ * @property newBounds - The new bounds for the strategy
+ * @property newBounds.lower - relative to the current tick
+ * @property newBounds.upper - relative to the current tick
+ */
+interface CLVaultStrategySettings {
+    newBounds: {
+        lower: number;
+        upper: number;
+    } | string;
+    lstContract?: ContractAddr;
+    truePrice?: number;
+    feeBps: number;
+    rebalanceConditions: {
+        minWaitHours: number;
+        direction: "any" | "uponly";
+        customShouldRebalance: (currentPoolPrice: number) => Promise<boolean>;
+    };
+    quoteAsset: TokenInfo;
+}
+declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount> {
+    /** Contract address of the strategy */
+    readonly address: ContractAddr;
+    /** Pricer instance for token price calculations */
+    readonly pricer: PricerBase;
+    /** Metadata containing strategy information */
+    readonly metadata: IStrategyMetadata<CLVaultStrategySettings>;
+    /** Contract instance for interacting with the strategy */
+    readonly contract: Contract;
+    readonly BASE_WEIGHT = 10000;
+    readonly ekuboPositionsContract: Contract;
+    readonly ekuboMathContract: Contract;
+    readonly lstContract: Contract | null;
+    poolKey: EkuboPoolKey | undefined;
+    readonly avnu: AvnuWrapper;
+    /**
+     * Creates a new VesuRebalance strategy instance.
+     * @param config - Configuration object containing provider and other settings
+     * @param pricer - Pricer instance for token price calculations
+     * @param metadata - Strategy metadata including deposit tokens and address
+     * @throws {Error} If more than one deposit token is specified
+     */
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>);
+    matchInputAmounts(amountInfo: DualActionAmount): Promise<DualActionAmount>;
+    /** Returns minimum amounts give given two amounts based on what can be added for liq */
+    getMinDepositAmounts(amountInfo: DualActionAmount): Promise<DualActionAmount>;
+    depositCall(amountInfo: DualActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    tokensToShares(amountInfo: DualActionAmount): Promise<Web3Number>;
+    withdrawCall(amountInfo: DualActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    rebalanceCall(newBounds: EkuboBounds, swapParams: SwapInfo): Call[];
+    handleUnusedCall(swapParams: SwapInfo): Call[];
+    handleFeesCall(): Call[];
+    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m' | '6m', range?: {
+        startTimestamp?: number;
+        endTimestamp?: number;
+    }): Promise<{
+        summary: DualTokenInfo;
+        history: FeeHistory[];
+    }>;
+    netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Ekubo CL Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
+    /**
+     * Calculates realized APY based on TVL per share growth, always valued in USDC.
+     * This is a vault-level metric (same for all users) and works for all strategies,
+     * regardless of quote asset configuration.
+     */
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    feeBasedAPY(timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
+    /**
+     * Calculates assets before and now in a given token of TVL per share to observe growth
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
+    getHarvestRewardShares(fromBlock: number, toBlock: number): Promise<Web3Number>;
+    balanceOf(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<Web3Number>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
+    _getTVL(blockIdentifier?: BlockIdentifier): Promise<{
+        amount0: Web3Number;
+        amount1: Web3Number;
+    }>;
+    totalSupply(blockIdentifier?: BlockIdentifier): Promise<Web3Number>;
+    assertValidDepositTokens(poolKey: EkuboPoolKey): void;
+    getTVL(blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
+    getUncollectedFees(): Promise<DualTokenInfo>;
+    getCurrentNFTID(): Promise<number>;
+    truePrice(): Promise<number>;
     getCurrentPrice(blockIdentifier?: BlockIdentifier): Promise<{
         price: number;
         tick: number;
@@ -652,7 +1084,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
             usdValue: number;
         };
     }>;
-    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
     assertValidBounds(bounds: EkuboBounds): void;
     assertValidAmounts(expectedAmounts: any, token0Bal: Web3Number, token1Bal: Web3Number): void;
     getSwapParams(expectedAmounts: any, poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number): {
@@ -672,7 +1104,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns {Promise<SwapInfo>}
      *
      */
-    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
     /**
      * Attempts to rebalance the vault by iteratively adjusting swap amounts if initial attempt fails.
      * Uses binary search approach to find optimal swap amount.
@@ -683,10 +1115,16 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number, sameErrorCount?: {
+        count: number;
+        error: null | string;
+    }, MAX_SAME_ERROR_COUNT?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;
@@ -705,7 +1143,8 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
         amount0: Web3Number;
         amount1: Web3Number;
     }>;
-    harvest(acc: Account, maxIterations?: number, priceRatioPrecision?: number): Promise<Call[]>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    harvest(acc: Account, maxIterations?: number, priceRatioPrecision?: number, minRewardAmount?: Web3Number): Promise<Call[]>;
     /**
      * @description This funciton requires atleast one of the pool tokens to be reward token
      * i.e. STRK.
@@ -754,13 +1193,387 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
  */
 declare const EkuboCLVaultStrategies: IStrategyMetadata<CLVaultStrategySettings>[];
 
-interface VesuPoolsInfo {
-    pools: any[];
-    isErrorPoolsAPI: boolean;
+interface SenseiVaultSettings {
+    mainToken: TokenInfo;
+    secondaryToken: TokenInfo;
+    targetHfBps: number;
+    feeBps: number;
 }
-declare enum VesuAmountType {
-    Delta = 0,
-    Target = 1
+declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+    readonly address: ContractAddr;
+    readonly metadata: IStrategyMetadata<SenseiVaultSettings>;
+    readonly pricer: PricerBase;
+    readonly contract: Contract;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>);
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<SingleTokenInfo>;
+    getTVL(): Promise<SingleTokenInfo>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    getPositionInfo(): Promise<{
+        collateralXSTRK: Web3Number;
+        collateralUSDValue: Web3Number;
+        debtSTRK: Web3Number;
+        debtUSDValue: Web3Number;
+        xSTRKPrice: number;
+        collateralInSTRK: number;
+    }>;
+    getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
+    getSettings: () => Promise<starknet.CallResult>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Sensei Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
+    netAPY(): Promise<number>;
+    /**
+     * Calculates user realized APY based on position growth accounting for deposits and withdrawals.
+     * Returns the APY as a number.
+     * Not implemented for Sensei Strategy yet.
+     */
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+}
+declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
+
+interface LeveledLogMethod {
+    (message: string, ...meta: any[]): void;
+    (message: any): void;
+}
+type LoggerLevel = "error" | "warn" | "info" | "verbose" | "debug";
+interface LoggerConfig {
+    level?: LoggerLevel;
+    consoleLevel?: LoggerLevel;
+    fileLevel?: LoggerLevel;
+    filePath?: string;
+    enableConsole?: boolean;
+    enableFile?: boolean;
+    colorizeConsole?: boolean;
+    shortErrorsInConsole?: boolean;
+    emitConfigLog?: boolean;
+}
+interface MyLogger {
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    info: LeveledLogMethod;
+    verbose: LeveledLogMethod;
+    debug: LeveledLogMethod;
+}
+declare const logger: MyLogger;
+declare function configureLogger(_config?: LoggerConfig): MyLogger;
+
+interface LeafData {
+    id: bigint;
+    readableId: string;
+    data: bigint[];
+}
+interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+    format: 'standard-v1';
+    leafEncoding: ValueType[];
+}
+declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
+    protected readonly tree: HexString[];
+    protected readonly values: StandardMerkleTreeData<LeafData>['values'];
+    protected readonly leafEncoding: ValueType[];
+    protected constructor(tree: HexString[], values: StandardMerkleTreeData<LeafData>['values'], leafEncoding: ValueType[]);
+    static of(values: LeafData[], leafEncoding?: ValueType[], options?: MerkleTreeOptions): StandardMerkleTree;
+    static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean;
+    static verifyMultiProof<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], multiproof: MultiProof<BytesLike, T>): boolean;
+    dump(): StandardMerkleTreeData<LeafData>;
+}
+
+/**
+ * Convert SDK TVL info (SingleTokenInfo or DualTokenInfo) to client AmountsInfo format
+ */
+declare function toAmountsInfo(tvlInfo: SingleTokenInfo | DualTokenInfo): Omit<AmountsInfo, "amounts"> & {
+    amounts: Array<{
+        amount: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+};
+/**
+ * Detect what capabilities a strategy instance has
+ */
+declare function detectCapabilities(strategy: BaseStrategy<any, any>): StrategyCapabilities;
+/**
+ * Check if a strategy is a dual-token strategy
+ */
+declare function isDualTokenStrategy(strategy: BaseStrategy<any, any>): boolean;
+
+type ParsedStarknetCall = {
+    target: string;
+    method: string;
+    selector?: string;
+    sanitizer?: string;
+    decodedArgs: unknown;
+    rawCalldata: string[];
+    parserUsed: string;
+    parseError?: string;
+};
+type StarknetCallParserOptions = {
+    tokenSymbols?: Record<string, string>;
+    tokenDecimals?: Record<string, number>;
+    poolNames?: Record<string, string>;
+};
+/**
+ * Integration guide for new methods/protocols:
+ * 1) Add method name to METHOD_BY_SELECTOR if it comes from ManageCall selector.
+ * 2) Add a decoder in METHOD_DECODERS with a focused decode* method.
+ * 3) Keep decoder output concise and operator-friendly.
+ * 4) Prefer existing primitives (ContractAddr, uint256, Web3Number where needed).
+ * 5) Add/extend tests in test/starknet-call-parser.test.ts for parse + log behavior.
+ */
+declare class StarknetCallParser {
+    private static readonly METHOD_DECODERS;
+    private static readonly METHOD_BY_SELECTOR;
+    static parseManageCall(manageCall: ManageCall, options?: StarknetCallParserOptions): ParsedStarknetCall;
+    static parseManageCalls(manageCalls: ManageCall[], options?: StarknetCallParserOptions): ParsedStarknetCall[];
+    static parseCall(call: Call, options?: StarknetCallParserOptions): ParsedStarknetCall;
+    static parseCalls(calls: Call[], options?: StarknetCallParserOptions): ParsedStarknetCall[];
+    static logManageCalls(context: string, manageCalls: ManageCall[], options?: StarknetCallParserOptions): void;
+    static logCalls(context: string, calls: Call[], options?: StarknetCallParserOptions): void;
+    static logCallsSummary(context: string, calls: Call[], options?: StarknetCallParserOptions, sink?: (message: string) => void): void;
+    static logManageCallsSummary(context: string, manageCalls: ManageCall[], options?: StarknetCallParserOptions, sink?: (message: string) => void): void;
+    static formatCallsSummary(context: string, calls: Call[], options?: StarknetCallParserOptions): string;
+    static formatManageCallsSummary(context: string, manageCalls: ManageCall[], options?: StarknetCallParserOptions): string;
+    static buildTokenSymbolLookup(tokens: TokenInfo[]): Record<string, string>;
+    static buildPoolNameLookup(pools: {
+        poolId: string | bigint;
+        name: string;
+    }[]): Record<string, string>;
+    static buildTokenDecimalsLookup(tokens: TokenInfo[]): Record<string, number>;
+    private static parseRaw;
+    private static enrichDecodedArgs;
+    private static toStringCalldata;
+    private static toBigInt;
+    private static decodeApprove;
+    private static decodeBringLiquidity;
+    private static decodeFlashLoan;
+    private static decodeModifyDelegation;
+    private static parseVesuAmount;
+    private static decodeModifyPosition;
+    private static decodeModifyLever;
+    private static decodeMultiRouteSwap;
+    private static decodeManageVaultWithMerkleVerification;
+    private static toCallSummary;
+    private static pickKeyFields;
+    private static u256FromParts;
+    private static toSelectorHex;
+    private static parseSwapArray;
+    private static toPoolIdKey;
+    private static toAssetLabel;
+    private static toHumanAmount;
+    private static toHumanAmountIfDecimals;
+    private static normalizeHex;
+    private static toAddressHex;
+    private static addressToString;
+}
+
+type RequiredFields<T> = {
+    [K in keyof T]-?: T[K];
+};
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+declare function assert(condition: boolean, message: string): void;
+declare function getTrovesEndpoint(): string;
+
+interface ManageCall {
+    proofReadableId: string;
+    sanitizer: ContractAddr;
+    call: {
+        contractAddress: ContractAddr;
+        selector: string;
+        calldata: bigint[];
+    };
+}
+interface SwapPriceInfo {
+    source: 'avnu' | 'ekubo';
+    fromTokenSymbol: string;
+    toTokenSymbol: string;
+    fromAmount: number;
+    toAmount: number;
+    effectivePrice: number;
+}
+interface DepositParams {
+    amount: Web3Number;
+}
+interface WithdrawParams {
+    amount: Web3Number;
+}
+type GenerateCallFn<T> = (params: T) => Promise<ManageCall[]>;
+type AdapterLeafType<T> = {
+    leaves: LeafData[];
+    callConstructor: GenerateCallFn<T>;
+};
+type LeafAdapterFn<T> = () => AdapterLeafType<T>;
+declare enum APYType {
+    BASE = "base",
+    REWARD = "reward",
+    LST = "lst"
+}
+interface SupportedPosition {
+    asset: TokenInfo;
+    isDebt: boolean;
+}
+interface BaseAdapterConfig {
+    baseToken: TokenInfo;
+    supportedPositions: SupportedPosition[];
+    networkConfig: IConfig;
+    pricer: PricerBase;
+    vaultAllocator: ContractAddr;
+    vaultAddress: ContractAddr;
+}
+type PositionAPY = {
+    apy: number;
+    type: APYType;
+};
+type PositionInfo = {
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
+    usdValue: number;
+    remarks: string;
+    apy: PositionAPY;
+    protocol: IProtocol;
+};
+type PositionAmount = {
+    amount: Web3Number;
+    remarks: string;
+};
+declare abstract class BaseAdapter<DepositParams, WithdrawParams> extends CacheClass {
+    readonly name: string;
+    readonly config: BaseAdapterConfig;
+    readonly protocol: IProtocol;
+    constructor(config: BaseAdapterConfig, name: string, protocol: IProtocol);
+    /**
+     * Loop through all supported positions and return amount, usd value, remarks and apy for each
+     */
+    getPositions(): Promise<PositionInfo[]>;
+    /**
+     * Implemented by child adapters to compute APY for a given supported position
+     */
+    protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    /**
+     * Implemented by child adapters to fetch amount for a given supported position
+     */
+    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
+    /**
+     * Implemented by child adapters to calculate maximum deposit positions
+     * @param amount Optional amount in baseToken to deposit
+     */
+    abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    /**
+     * Implemented by child adapters to calculate maximum withdraw positions
+     */
+    abstract maxWithdraw(): Promise<PositionInfo>;
+    /**
+     * Uses pricer to convert an amount of an asset to USD value
+     */
+    protected getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number>;
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
+    /**
+     * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+     */
+    protected abstract _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    /**
+     * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+     */
+    protected abstract _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    /**
+     * Returns deposit leaf adapter using configured proof id
+     */
+    getDepositLeaf(): AdapterLeafType<DepositParams>;
+    /**
+     * Returns withdraw leaf adapter using configured proof id
+     */
+    getWithdrawLeaf(): AdapterLeafType<WithdrawParams>;
+    /**
+     * Implementor must provide deposit call
+     * @param params
+     */
+    abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    /**
+     * Implementor must provide withdraw call
+     * @param params
+     */
+    abstract getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getProofs<T>(isDeposit: boolean, tree: StandardMerkleTree): {
+        proofs: string[][];
+        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
+    };
+    getNetAPY(): Promise<number>;
+    abstract getHealthFactor(): Promise<number>;
+}
+
+interface FlashloanCallParams {
+    amount: Web3Number;
+    data: bigint[];
+}
+interface ApproveCallParams {
+    amount: Web3Number;
+}
+interface AvnuSwapCallParams {
+    props: SwapInfo;
+}
+interface CommonAdapterConfig {
+    id: string;
+    vaultAddress: ContractAddr;
+    vaultAllocator: ContractAddr;
+    manager: ContractAddr;
+    asset: ContractAddr;
+}
+declare class CommonAdapter {
+    config: CommonAdapterConfig;
+    constructor(config: CommonAdapterConfig);
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
+    getFlashloanAdapter(): Promise<AdapterLeafType<FlashloanCallParams>>;
+    getFlashloanCall(params: FlashloanCallParams): Promise<ManageCall[]>;
+    getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveCall(token: ContractAddr, spender: ContractAddr, proofReadableId: string): (params: ApproveCallParams) => Promise<{
+        proofReadableId: string;
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    }[]>;
+    getBringLiquidityCall(proofReadableId: string): GenerateCallFn<ApproveCallParams>;
+}
+
+interface VesuPoolsInfo {
+    pools: any[];
+    isErrorPoolsAPI: boolean;
+}
+declare enum VesuAmountType {
+    Delta = 0,
+    Target = 1
 }
 declare enum VesuAmountDenomination {
     Native = 0,
@@ -852,6 +1665,28 @@ declare const VesuPools: {
     Re7xSTRK: ContractAddr;
     Re7xBTC: ContractAddr;
     Re7USDCPrime: ContractAddr;
+    Prime: ContractAddr;
+    Re7STRK: ContractAddr;
+};
+declare const VesuPoolMetadata: {
+    [VesuPools.Genesis.address]: {
+        name: string;
+    };
+    [VesuPools.Re7xSTRK.address]: {
+        name: string;
+    };
+    [VesuPools.Re7xBTC.address]: {
+        name: string;
+    };
+    [VesuPools.Prime.address]: {
+        name: string;
+    };
+    [VesuPools.Re7STRK.address]: {
+        name: string;
+    };
+    [VesuPools.Re7USDCPrime.address]: {
+        name: string;
+    };
 };
 declare const extensionMap: {
     [key: string]: ContractAddr;
@@ -863,11 +1698,42 @@ declare function getVesuSingletonAddress(vesuPool: ContractAddr): {
 declare class VesuAdapter extends CacheClass {
     VESU_MULTIPLY_V1: ContractAddr;
     VESU_MULTIPLY: ContractAddr;
+    VESU_WITHDRAW_SWAP_FIXED_MULTIPLIER: ContractAddr;
     config: VesuAdapterConfig;
     networkConfig: IConfig | undefined;
     pricer: PricerBase | undefined;
     constructor(config: VesuAdapterConfig);
-    getVesuModifyDelegationCall: (params: VesuModifyDelegationCallParams) => ManageCall;
+    static getDefaultModifyPositionCallParams(params: {
+        collateralAmount: Web3Number;
+        isAddCollateral: boolean;
+        debtAmount: Web3Number;
+        isBorrow: boolean;
+    }): {
+        collateralAmount: {
+            amount_type: VesuAmountType;
+            denomination: VesuAmountDenomination;
+            value: {
+                abs: Web3Number;
+                is_negative: boolean;
+            };
+        };
+        debtAmount: {
+            amount_type: VesuAmountType;
+            denomination: VesuAmountDenomination;
+            value: {
+                abs: Web3Number;
+                is_negative: boolean;
+            };
+        };
+    };
+    getVesuModifyDelegationCall: (delegatee: ContractAddr) => (params: VesuModifyDelegationCallParams) => {
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    };
     formatAmountTypeEnum(amountType: VesuAmountType): CairoCustomEnum;
     formatAmountDenominationEnum(denomination: VesuAmountDenomination): CairoCustomEnum;
     getVesuSingletonContract(config: IConfig, poolId: ContractAddr): {
@@ -876,7 +1742,11 @@ declare class VesuAdapter extends CacheClass {
     };
     getDebtCap(config: IConfig): Promise<Web3Number>;
     getCurrentDebtUtilisationAmount(config: IConfig): Promise<Web3Number>;
-    getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number): Promise<Web3Number>;
+    getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number): Promise<{
+        maxDebtToHave: Web3Number;
+        currentDebt: Web3Number;
+        totalSupply: Web3Number;
+    }>;
     getLTVConfig(config: IConfig, blockNumber?: BlockIdentifier): Promise<number>;
     getPositions(config: IConfig, blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
     getCollateralization(config: IConfig, blockNumber?: BlockIdentifier): Promise<Omit<VaultPosition, 'amount'>[]>;
@@ -913,6 +1783,9 @@ declare class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawP
     readonly config: VesuSupplyOnlyAdapterConfig;
     readonly tokenMarketData: TokenMarketData;
     constructor(config: VesuSupplyOnlyAdapterConfig);
+    private _depositApproveProofReadableId;
+    private _depositCallProofReadableId;
+    private _withdrawCallProofReadableId;
     protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
     protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
@@ -938,23 +1811,50 @@ declare class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawP
     getHealthFactor(): Promise<number>;
 }
 
+interface VesuDepositParams {
+    amount: Web3Number;
+    marginSwap?: {
+        marginToken: TokenInfo;
+    };
+    leverSwap?: {
+        exactOutput?: Web3Number;
+    };
+}
+interface VesuWithdrawParams {
+    amount: Web3Number;
+    withdrawSwap?: {
+        outputToken: TokenInfo;
+    };
+}
 interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
     poolId: ContractAddr;
     collateral: TokenInfo;
     debt: TokenInfo;
+    marginToken: TokenInfo;
     targetHealthFactor: number;
     minHealthFactor: number;
     quoteAmountToFetchPrice: Web3Number;
     minimumVesuMovementAmount: number;
+    maxSlippage?: number;
 }
-declare class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+declare class VesuMultiplyAdapter extends BaseAdapter<VesuDepositParams, VesuWithdrawParams> {
     readonly config: VesuMultiplyAdapterConfig;
-    readonly vesuAdapter: VesuAdapter;
+    readonly _vesuAdapter: VesuAdapter;
     readonly tokenMarketData: TokenMarketData;
     readonly minimumVesuMovementAmount: number;
+    lastSwapPriceInfo: SwapPriceInfo | null;
+    maxSlippage: number;
     constructor(config: VesuMultiplyAdapterConfig);
+    private _getMultiplyContract;
+    private _buildDelegationWrappedCalls;
+    private _getDepositProofReadableIds;
+    private _getWithdrawProofReadableIds;
+    private _buildZeroAmountSwapsWithWeights;
+    private _fetchPositionAndPrices;
+    private _computeTargetDebtDelta;
+    private _getPositionCommonContext;
     protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
-    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
     maxBorrowableAPY(): Promise<number>;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     maxWithdraw(): Promise<PositionInfo>;
@@ -972,18 +1872,79 @@ declare class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawPar
         sanitizer: ContractAddr;
         id: string;
     }[];
-    getDepositAdapter(): AdapterLeafType<DepositParams>;
-    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    private getMultiplyCallCalldata;
-    private getLeverParams;
-    private getWithdrawalCalldata;
+    getDepositAdapter(approveToken?: TokenInfo): AdapterLeafType<VesuDepositParams>;
+    getWithdrawAdapter(): AdapterLeafType<VesuWithdrawParams>;
+    getDepositCall(params: VesuDepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: VesuWithdrawParams): Promise<ManageCall[]>;
+    private _getIncreaseCalldata;
+    private _buildDecreaseLikeCalldata;
+    private _getDecreaseCalldata;
     formatMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams): {
         action: CairoCustomEnum;
     };
     getHealthFactor(): Promise<number>;
-    getNetAPY(): Promise<number>;
+    getNetAPY(): Promise<number>;
+}
+
+interface VesuModifyPositionDepositParams {
+    amount: Web3Number;
+    debtAmount?: Web3Number;
+}
+interface VesuModifyPositionWithdrawParams {
+    amount: Web3Number;
+    debtAmount?: Web3Number;
+}
+interface VesuModifyPositionAdapterConfig extends BaseAdapterConfig {
+    poolId: ContractAddr;
+    collateral: TokenInfo;
+    debt: TokenInfo;
+    targetLtv: number;
+    maxLtv: number;
+}
+declare class VesuModifyPositionAdapter extends BaseAdapter<VesuModifyPositionDepositParams, VesuModifyPositionWithdrawParams> {
+    readonly config: VesuModifyPositionAdapterConfig;
+    readonly _vesuAdapter: VesuAdapter;
+    private readonly _tokenMarketData;
+    constructor(config: VesuModifyPositionAdapterConfig);
+    private _prepareVesuAdapter;
+    private _getTargetHealthFactor;
+    private _getPositionCommonContext;
+    private _getEffectiveMaxLtv;
+    private _toSigned;
+    private _depositApproveProofReadableId;
+    private _depositModifyProofReadableId;
+    private _withdrawApproveProofReadableId;
+    private _withdrawModifyProofReadableId;
+    private _clampWithdrawCollateral;
+    private _clampRepayDebt;
+    private _normalizeDebtAmountFromHelper;
+    private _getState;
+    private _buildDefaultDepositDeltas;
+    private _buildDefaultWithdrawDeltas;
+    private _amountStruct;
+    private _getModifyPositionCall;
+    private _getApproveCall;
+    protected getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    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: VesuModifyPositionDepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: VesuModifyPositionWithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
 
 /**
@@ -1057,9 +2018,10 @@ declare enum AssetOperationType {
     TRANSFER = "TRANSFER"
 }
 declare enum AssetOperationStatus {
-    PENDING = "PENDING",
+    CREATED = "CREATED",
+    IN_PROGRESS = "IN_PROGRESS",
     COMPLETED = "COMPLETED",
-    FAILED = "FAILED"
+    REJECTED = "REJECTED"
 }
 interface SettlementSignature {
     r: string;
@@ -1240,7 +2202,8 @@ interface ExtendedApiResponse<T> {
     data: T;
 }
 interface ExtendedWrapperConfig {
-    baseUrl: string;
+    readUrl: string;
+    writeUrl: string;
     apiKey?: string;
     timeout?: number;
     retries?: number;
@@ -1254,6 +2217,25 @@ interface FundingRate {
     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
@@ -1261,7 +2243,8 @@ interface FundingRate {
  */
 
 declare class ExtendedWrapper {
-    private baseUrl;
+    private readUrl;
+    private writeUrl;
     private apiKey?;
     private timeout;
     private retries;
@@ -1279,10 +2262,10 @@ declare class ExtendedWrapper {
      */
     getMarkets(marketNames?: string): Promise<ExtendedApiResponse<Market[]>>;
     /**
-    *
-    * @param orderId - The ID of the order to get
-    * @returns The order
-    */
+     *
+     * @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
@@ -1346,21 +2329,23 @@ declare class ExtendedWrapper {
      */
     createBuyOrder(marketName: string, amount: string, price: string, options?: {
         postOnly?: boolean;
+        reduceOnly?: boolean;
         previousOrderId?: number;
         externalId?: string;
         timeInForce?: TimeInForce;
     }): Promise<ExtendedApiResponse<PlacedOrder>>;
     /**
-    * Get order by ID
-    * @param orderId - The ID of the order to get
-    * @returns The order
-    */
+     * 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?: {
         postOnly?: boolean;
+        reduceOnly?: boolean;
         previousOrderId?: number;
         externalId?: string;
         timeInForce?: TimeInForce;
@@ -1393,32 +2378,11 @@ declare class ExtendedWrapper {
      * @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[]>>;
-}
-
-interface Route {
-    token_from: string;
-    token_to: string;
-    exchange_address: string;
-    percent: number;
-    additional_swap_params: string[];
-}
-interface SwapInfo {
-    token_from_address: string;
-    token_from_amount: Uint256;
-    token_to_address: string;
-    token_to_amount: Uint256;
-    token_to_min_amount: Uint256;
-    beneficiary: string;
-    integrator_fee_amount_bps: number;
-    integrator_fee_recipient: string;
-    routes: Route[];
-}
-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[][]>;
+    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 {
@@ -1431,9 +2395,16 @@ interface AvnuAdapterConfig extends BaseAdapterConfig {
 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>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     maxWithdraw(): Promise<PositionInfo>;
     protected _getDepositLeaf(): {
@@ -1462,9 +2433,6 @@ declare class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     getSwapCallData(quote: Quote): Promise<bigint[][]>;
     getHealthFactor(): Promise<number>;
     fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
-    getQuotesAvnu(from_token_address: string, to_token_address: string, amount: number, //amount in btc units
-    takerAddress: string, toTokenDecimals: number, usdcToBtc: boolean, maxIterations?: number, tolerance?: number): Promise<Quote | null>;
-    getPriceOfToken(tokenAddress: string, retries?: number): Promise<number | null>;
 }
 
 interface ExtendedAdapterConfig extends BaseAdapterConfig {
@@ -1484,9 +2452,12 @@ interface ExtendedAdapterConfig extends BaseAdapterConfig {
 declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     readonly config: ExtendedAdapterConfig;
     readonly client: ExtendedWrapper;
+    readonly usdceToken: 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;
@@ -1502,14 +2473,6 @@ declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams>
         sanitizer: ContractAddr;
         id: string;
     }[];
-    getSwapFromLegacyLeaf(): AdapterLeafType<DepositParams>;
-    protected _getSwapFromLegacyLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
     protected _getWithdrawLeaf(): {
         target: ContractAddr;
         method: string;
@@ -1518,11 +2481,6 @@ declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams>
         id: string;
     }[];
     getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): {
-        proofs: string[][];
-        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
-    };
-    getSwapFromLegacyCall(params: DepositParams): Promise<ManageCall[]>;
     getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
     withdrawFromExtended(amount: Web3Number): Promise<{
         status: boolean;
@@ -1532,9 +2490,8 @@ declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams>
     getExtendedDepositAmount(): Promise<Balance | undefined>;
     setLeverage(leverage: string, marketName: string): Promise<boolean>;
     getAllOpenPositions(): Promise<Position[] | null>;
-    getOrderHistory(marketName: string): Promise<OpenOrder[] | null>;
     getOrderStatus(orderId: string, marketName: string): Promise<OpenOrder | null>;
-    fetchOrderBookBTCUSDC(): Promise<{
+    fetchOrderBookFromExtended(): Promise<{
         status: boolean;
         bid: Web3Number;
         ask: Web3Number;
@@ -1563,14 +2520,30 @@ declare const AVNU_EXCHANGE_FOR_LEGACY_USDC: ContractAddr;
 declare const AVNU_QUOTE_URL = "https://starknet.api.avnu.fi/swap/v3/quotes";
 declare const EXTENDED_CONTRACT: ContractAddr;
 declare const VESU_SINGLETON: ContractAddr;
+declare const TRANSFER_SANITIZER: ContractAddr;
 declare function toBigInt(value: string | number): bigint;
 
-interface UnusedBalanceAdapterConfig extends BaseAdapterConfig {
+interface TokenTransferAdapterConfig extends BaseAdapterConfig {
+    /** Address that funds are sent FROM during deposit (and returned TO during withdraw) */
+    fromAddress: ContractAddr;
+    /** Address that funds are sent TO during deposit (and pulled FROM during withdraw) */
+    toAddress: ContractAddr;
 }
-declare class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: UnusedBalanceAdapterConfig;
+/**
+ * Adapter for transferring a single token between two fixed addresses.
+ *
+ * Deposit: transfers baseToken from `fromAddress` → `toAddress`
+ * Withdraw: transfers baseToken from `toAddress` → `fromAddress` (requires toAddress to approve fromAddress/VA)
+ *
+ * Proof IDs are derived from `tr_<symbol>_<toAddrShort>` to be unique per token+destination pair.
+ */
+declare class TokenTransferAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: TokenTransferAdapterConfig;
     readonly tokenMarketData: TokenMarketData;
-    constructor(config: UnusedBalanceAdapterConfig);
+    constructor(config: TokenTransferAdapterConfig);
+    private _idBase;
+    private _depositCallProofReadableId;
+    private _withdrawCallProofReadableId;
     protected getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY>;
     protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
     maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
@@ -1589,464 +2562,170 @@ declare class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawPa
         sanitizer: ContractAddr;
         id: string;
     }[];
-    getHealthFactor(): Promise<number>;
     getDepositCall(params: DepositParams): Promise<ManageCall[]>;
     getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
 
-interface SingleActionAmount {
-    tokenInfo: TokenInfo;
-    amount: Web3Number;
-}
-interface SingleTokenInfo extends SingleActionAmount {
-    usdValue: number;
-}
-interface APYInfo {
-    net: number;
-    splits: {
-        apy: number;
-        id: string;
-    }[];
-}
-interface DualActionAmount {
-    token0: SingleActionAmount;
-    token1: SingleActionAmount;
-}
-interface DualTokenInfo {
-    usdValue: number;
-    token0: SingleTokenInfo;
-    token1: SingleTokenInfo;
-}
-interface CacheData {
-    timestamp: number;
-    ttl: number;
-    data: any;
-}
-declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
-    readonly config: IConfig;
-    readonly cache: Map<string, CacheData>;
-    constructor(config: IConfig);
-    getUserTVL(user: ContractAddr): Promise<TVLInfo>;
-    getTVL(): Promise<TVLInfo>;
-    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getUnusedBalance(): Promise<SingleTokenInfo>;
-    netAPY(): Promise<APYInfo>;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
-    }>;
-    getHealthFactors(): Promise<number[]>;
-}
-
-/**
- * TokenMarketData class that combines LST APR and Midas modules
- * to provide unified APY, price, and TVL functions for tokens
- */
-declare class TokenMarketData {
-    private pricer;
-    private config;
-    constructor(pricer: PricerBase, config: IConfig);
-    /**
-     * Get APY for a token
-     * - If it's an LST token, returns LST APY
-     * - If it's a Midas token, returns Midas APY
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get APY for
-     * @returns APY in absolute terms (not percentage)
-     */
-    getAPY(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get price for a token using the pricer module
-     * @param tokenInfo The token to get price for
-     * @returns Price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    getPrice(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get true price for a token
-     * - For LST tokens: Uses convert_to_assets to get true exchange rate
-     * - For Midas tokens: Uses Midas price API
-     * - For other tokens: Falls back to regular pricer
-     * @param tokenInfo The token to get true price for
-     * @returns True price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    getTruePrice(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get TVL for a token
-     * - If it's a Midas token, returns Midas TVL data
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get TVL for
-     * @returns TVL as SingleTokenInfo or 0
-     */
-    getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo>;
-    /**
-     * Check if a token is supported for APY data
-     * @param tokenInfo The token to check
-     * @returns True if the token has APY data available
-     */
-    isAPYSupported(tokenInfo: TokenInfo): boolean;
-    /**
-     * Check if a token is supported for TVL data
-     * @param tokenInfo The token to check
-     * @returns True if the token has TVL data available
-     */
-    isTVLSupported(tokenInfo: TokenInfo): boolean;
-}
-
-declare class Pragma {
-    contractAddr: string;
-    readonly contract: Contract;
-    constructor(provider: RpcProvider);
-    getPrice(tokenAddr: string): Promise<number>;
-}
-
-declare class ZkLend extends ILending implements ILending {
-    readonly pricer: Pricer;
-    static readonly POOLS_URL = "https://app.zklend.com/api/pools";
-    private POSITION_URL;
-    constructor(config: IConfig, pricer: Pricer);
-    init(): Promise<void>;
-    /**
-     * @description Get the health factor of the user for given lending and debt tokens
-     * @param lending_tokens
-     * @param debt_tokens
-     * @param user
-     * @returns hf (e.g. returns 1.5 for 150% health factor)
-     */
-    get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number>;
-    /**
-     * @description Get the health factor of the user
-     * - Considers all tokens for collateral and debt
-     */
-    get_health_factor(user: ContractAddr): Promise<number>;
-    getPositionsSummary(user: ContractAddr): Promise<{
-        collateralUSD: number;
-        debtUSD: number;
-    }>;
-    /**
-     * @description Get the token-wise collateral and debt positions of the user
-     * @param user Contract address of the user
-     * @returns Promise<ILendingPosition[]>
-     */
-    getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
-}
-
-declare class PricerFromApi extends PricerBase {
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-    getPriceFromMyAPI(tokenSymbol: string): Promise<{
-        price: number;
-        timestamp: Date;
-    }>;
-}
-
-declare class ERC20 {
-    readonly config: IConfig;
-    constructor(config: IConfig);
-    contract(addr: string | ContractAddr): Contract;
-    balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
-    allowance(token: string | ContractAddr, owner: string | ContractAddr, spender: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
-    transfer(token: string | ContractAddr, to: string | ContractAddr, amount: Web3Number): starknet.Call;
-    approve(token: string | ContractAddr, spender: string | ContractAddr, amount: Web3Number): starknet.Call;
-}
-
-declare class AutoCompounderSTRK {
-    readonly config: IConfig;
-    readonly addr: ContractAddr;
-    readonly pricer: Pricer;
-    private initialized;
-    contract: Contract | null;
-    readonly metadata: {
-        decimals: number;
-        underlying: {
-            address: ContractAddr;
-            name: string;
-            symbol: string;
-        };
-        name: string;
-    };
-    constructor(config: IConfig, pricer: Pricer);
-    init(): Promise<void>;
-    waitForInitilisation(): Promise<void>;
-    /** Returns shares of user */
-    balanceOf(user: ContractAddr): Promise<Web3Number>;
-    /** Returns underlying assets of user */
-    balanceOfUnderlying(user: ContractAddr): Promise<Web3Number>;
-    /** Returns usd value of assets */
-    usdBalanceOfUnderlying(user: ContractAddr): Promise<{
-        usd: Web3Number;
-        assets: Web3Number;
-    }>;
+declare enum LSTPriceType {
+    ENDUR_PRICE = "ENDUR_PRICE",
+    AVNU_PRICE = "AVNU_PRICE"
 }
 
-interface PoolProps {
-    pool_id: ContractAddr;
-    max_weight: number;
-    v_token: ContractAddr;
-}
-interface Change {
-    pool_id: ContractAddr;
-    changeAmt: Web3Number;
-    finalAmt: Web3Number;
-    isDeposit: boolean;
+interface UniversalManageCall {
+    proofs: string[];
+    manageCall: ManageCall;
+    step: UNIVERSAL_MANAGE_IDS;
 }
-interface VesuRebalanceSettings {
-    feeBps: number;
+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;
 }
-interface PoolInfoFull {
-    pool_id: ContractAddr;
-    pool_name: string | undefined;
-    max_weight: number;
-    current_weight: number;
-    v_token: ContractAddr;
-    amount: Web3Number;
-    usdValue: Web3Number;
-    APY: {
-        baseApy: number;
-        defiSpringApy: number;
-        netApy: number;
-    };
-    currentUtilization: number;
-    maxUtilization: number;
+declare enum AUMTypes {
+    FINALISED = "finalised",
+    DEFISPRING = "defispring"
 }
-/**
- * Represents a VesuRebalance strategy.
- * This class implements an automated rebalancing strategy for Vesu pools,
- * managing deposits and withdrawals while optimizing yield through STRK rewards.
- */
-declare class VesuRebalance extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+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<VesuRebalanceSettings>;
+    readonly metadata: IStrategyMetadata<S>;
     /** Contract instance for interacting with the strategy */
     readonly contract: Contract;
-    readonly BASE_WEIGHT = 10000;
-    /**
-     * Creates a new VesuRebalance strategy instance.
-     * @param config - Configuration object containing provider and other settings
-     * @param pricer - Pricer instance for token price calculations
-     * @param metadata - Strategy metadata including deposit tokens and address
-     * @throws {Error} If more than one deposit token is specified
-     */
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>);
-    /**
-     * Creates a deposit call to the strategy contract.
-     * @param assets - Amount of assets to deposit
-     * @param receiver - Address that will receive the strategy tokens
-     * @returns Populated contract call for deposit
-     */
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<starknet.Call[]>;
-    /**
-     * Creates a withdrawal call to the strategy contract.
-     * @param assets - Amount of assets to withdraw
-     * @param receiver - Address that will receive the withdrawn assets
-     * @param owner - Address that owns the strategy tokens
-     * @returns Populated contract call for withdrawal
-     */
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<starknet.Call[]>;
-    /**
-     * Returns the underlying asset token of the strategy.
-     * @returns The deposit token supported by this strategy
-     */
+    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;
-    /**
-     * Returns the number of decimals used by the strategy token.
-     * @returns Number of decimals (same as the underlying token)
-     */
-    decimals(): number;
-    /**
-     * Calculates the Total Value Locked (TVL) for a specific user.
-     * @param user - Address of the user
-     * @returns Object containing the amount in token units and USD value
-     */
-    getUserTVL(user: ContractAddr): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }>;
-    /**
-     * Calculates the total TVL of the strategy.
-     * @returns Object containing the total amount in token units and USD value
-     */
-    getTVL(): Promise<{
+    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;
     }>;
-    static getAllPossibleVerifiedPools(asset: ContractAddr): Promise<any>;
-    getPoolInfo(p: PoolProps, pools: any[], vesuPositions: any[], totalAssets: Web3Number, isErrorPositionsAPI: boolean, isErrorPoolsAPI: boolean): Promise<{
-        pool_id: ContractAddr;
-        pool_name: any;
-        max_weight: number;
-        current_weight: number;
-        v_token: ContractAddr;
-        amount: Web3Number;
-        usdValue: Web3Number;
-        APY: {
-            baseApy: number;
-            defiSpringApy: number;
-            netApy: number;
-        };
-        currentUtilization: number;
-        maxUtilization: number;
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
     }>;
     /**
-     * Retrieves the list of allowed pools and their detailed information from multiple sources:
-     * 1. Contract's allowed pools
-     * 2. Vesu positions API for current positions
-     * 3. Vesu pools API for APY and utilization data
-     *
-     * @returns {Promise<{
-     *   data: Array<PoolInfoFull>,
-     *   isErrorPositionsAPI: boolean
-     * }>} Object containing:
-     *   - data: Array of pool information including IDs, weights, amounts, APYs and utilization
-     *   - isErrorPositionsAPI: Boolean indicating if there was an error fetching position data
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
      */
-    getPools(): Promise<{
-        data: {
-            pool_id: ContractAddr;
-            pool_name: any;
-            max_weight: number;
-            current_weight: number;
-            v_token: ContractAddr;
-            amount: Web3Number;
-            usdValue: Web3Number;
-            APY: {
-                baseApy: number;
-                defiSpringApy: number;
-                netApy: number;
-            };
-            currentUtilization: number;
-            maxUtilization: number;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
         }[];
-        isErrorPositionsAPI: boolean;
-        isErrorPoolsAPI: boolean;
-        isError: boolean;
     }>;
-    getVesuPools(retry?: number): Promise<{
-        pools: any[];
-        isErrorPoolsAPI: boolean;
+    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 the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
-     */
-    netAPY(): Promise<APYInfo>;
-    /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * Calculates user realized APY based on trueSharesBasedAPY method.
+     * Returns the APY as a number.
      */
-    netAPYGivenPools(pools: PoolInfoFull[]): Promise<number>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
     /**
-     * Calculates optimal position changes to maximize APY while respecting max weights.
-     * The algorithm:
-     * 1. Sorts pools by APY (highest first)
-     * 2. Calculates target amounts based on max weights
-     * 3. For each pool that needs more funds:
-     *    - Takes funds from lowest APY pools that are over their target
-     * 4. Validates that total assets remain constant
-     *
-     * @returns {Promise<{
-     *   changes: Change[],
-     *   finalPools: PoolInfoFull[],
-     *   isAnyPoolOverMaxWeight: boolean
-     * }>} Object containing:
-     *   - changes: Array of position changes
-     *   - finalPools: Array of pool information after rebalance
-     * @throws Error if rebalance is not possible while maintaining constraints
-     */
-    getRebalancedPositions(_pools?: PoolInfoFull[]): Promise<{
-        changes: never[];
-        finalPools: never[];
-        isAnyPoolOverMaxWeight?: undefined;
-    } | {
-        changes: Change[];
-        finalPools: PoolInfoFull[];
-        isAnyPoolOverMaxWeight: boolean;
+       * 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;
     /**
-     * Creates a rebalance Call object for the strategy contract
-     * @param pools - Array of pool information including IDs, weights, amounts, APYs and utilization
-     * @returns Populated contract call for rebalance
-     */
-    getRebalanceCall(pools: Awaited<ReturnType<typeof this.getRebalancedPositions>>["changes"], isOverWeightAdjustment: boolean): Promise<starknet.Call | null>;
-    getInvestmentFlows(pools: PoolInfoFull[]): Promise<IInvestmentFlow[]>;
-    harvest(acc: Account, endpoint?: string): Promise<starknet.Call[]>;
-    /**
-     * Calculates the fees deducted in different vTokens based on the current and previous state.
-     * @param previousTotalSupply - The total supply of the strategy token before the transaction
-     * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
-     */
-    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
-        vToken: ContractAddr;
-        fee: Web3Number;
-    }>>;
-}
-/**
- * Represents the Vesu Rebalance Strategies.
- */
-declare const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[];
-
-interface SenseiVaultSettings {
-    mainToken: TokenInfo;
-    secondaryToken: TokenInfo;
-    targetHfBps: number;
-    feeBps: number;
-}
-declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
-    readonly address: ContractAddr;
-    readonly metadata: IStrategyMetadata<SenseiVaultSettings>;
-    readonly pricer: PricerBase;
-    readonly contract: Contract;
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>);
-    getUserTVL(user: ContractAddr): Promise<SingleTokenInfo>;
-    getTVL(): Promise<SingleTokenInfo>;
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    getPositionInfo(): Promise<{
-        collateralXSTRK: Web3Number;
-        collateralUSDValue: Web3Number;
-        debtSTRK: Web3Number;
-        debtUSDValue: Web3Number;
-        xSTRKPrice: number;
-        collateralInSTRK: number;
+     * 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;
     }>;
-    getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
-    getSettings: () => Promise<starknet.CallResult>;
-}
-declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
-
-interface UniversalManageCall {
-    proofs: string[];
-    manageCall: ManageCall;
-    step: UNIVERSAL_MANAGE_IDS;
-}
-interface UniversalStrategySettings {
-    vaultAddress: ContractAddr;
-    manager: ContractAddr;
-    vaultAllocator: ContractAddr;
-    redeemRequestNFT: ContractAddr;
-    leafAdapters: LeafAdapterFn<any>[];
-    adapters: {
-        id: string;
-        adapter: BaseAdapter<DepositParams, WithdrawParams>;
-    }[];
-}
-declare enum AUMTypes {
-    FINALISED = "finalised",
-    DEFISPRING = "defispring"
-}
-declare enum PositionTypeAvnuExtended {
-    OPEN = "open",
-    CLOSE = "close"
+    getRebalanceCall(params: {
+        isLeg1toLeg2: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
 }
 declare enum UNIVERSAL_MANAGE_IDS {
     FLASH_LOAN = "flash_loan_init",
@@ -2060,12 +2739,18 @@ declare enum UNIVERSAL_MANAGE_IDS {
     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.
@@ -2089,11 +2774,20 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
      * Returns the asset token for this strategy
      */
     asset(): TokenInfo;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
     /**
      * Returns the unused balance in the vault allocator.
      * Note: This function is common for any SVK strategy.
      */
     getUnusedBalance(): Promise<SingleTokenInfo>;
+    /**
+      * Builds a manage call from an adapter's proof tree.
+      * DRY helper for the repeated getProofs → getManageCall pattern.
+      */
+    protected buildManageCallFromAdapter(adapter: {
+        getProofs: (isDeposit: boolean, tree: any) => any;
+    }, isDeposit: boolean, amount: Web3Number): Promise<Call>;
     /**
      * Bridges liquidity from the vault allocator back to the vault.
      * Note: This function is common for any SVK strategy.
@@ -2101,6 +2795,11 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
     getBringLiquidityCall(params: {
         amount: Web3Number;
     }): Promise<Call>;
+    /**
+     * Resolves ordered merkle proofs from emitted manage calls.
+     * This ensures only runtime-required proofs are passed to manager calls.
+     */
+    protected getProofGroupsForManageCalls(manageCalls: ManageCall[]): string[][];
     /**
      * Gets all leaves from all leaf adapters.
      * Note: This function is common for any SVK strategy.
@@ -2163,27 +2862,791 @@ declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     getTag(): string;
     getVesuSameTokenAdapter(): VesuMultiplyAdapter;
     getVesuAdapters(): VesuMultiplyAdapter[];
+    getRewardsAUM(_prevAum: Web3Number): Promise<Web3Number>;
+    getLSTDexPrice(): Promise<number>;
+    getLSTAvnuRate(): Promise<number>;
+    getLSTExchangeRate(): Promise<number>;
+    private _getMinOutputAmountLSTBuy;
+    private _getMinOutputAmountLSTSell;
+    /**
+     * Uses vesu's multiple call to create leverage on LST
+     * Deposit amount is in LST
+     * @param params
+     */
+    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>[];
+
+/**
+ * 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 {
+    /** P1: Deposit USDC.e from operator wallet directly to Extended exchange */
+    WALLET_TO_EXTENDED = "WALLET_TO_EXTENDED",
+    /** P2: USDC from vault allocator → swap to USDC.e → deposit to Extended */
+    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.e 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 {
+    LTV_VESU_LOW_TO_EXTENDED = "LTV_VESU_LOW_TO_EXTENDED",
+    LTV_EXTENDED_PROFITABLE_AVAILABLE = "LTV_EXTENDED_PROFITABLE_AVAILABLE",
+    LTV_EXTENDED_PROFITABLE_REALIZE = "LTV_EXTENDED_PROFITABLE_REALIZE",
+    LTV_VESU_HIGH_USE_VA_OR_WALLET = "LTV_VESU_HIGH_USE_VA_OR_WALLET",
+    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[];
+}
+/**
+ * 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;
+    assetToken: TokenInfo;
+    /** USDC.e token for wallet balance checks during route computation */
+    usdceToken: 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.
+ *
+ * Holds both the refreshed on-chain/off-chain state snapshots AND the
+ * budget-tracking values consumed by sub-classifiers.  Spend methods
+ * automatically keep `totalUnused` in sync.  State-mutation methods
+ * (`applyVesuDelta`, `applyExtendedExposureDelta`, `applyExtendedBalanceChange`)
+ * update the underlying snapshots so that downstream classifiers always
+ * see the most up-to-date picture.
+ */
+declare class SolveBudget {
+    unusedBalance: TokenBalance[];
+    walletBalance: TokenBalance | null;
+    vaultBalance: TokenBalance | null;
+    extendedPositions: ExtendedPositionState[];
+    extendedBalance: ExtendedBalanceState | null;
+    vesuPoolStates: VesuPoolState[];
+    vesuPerPoolDebtDeltasToBorrow: Web3Number[];
+    shouldVesuRebalance: boolean[];
+    private _vaUsd;
+    private _walletUsd;
+    private _extAvailWithdraw;
+    private _extAvailUpnl;
+    private _extAvailTrade;
+    private _extPendingDeposit;
+    private _vesuBorrowCapacity;
+    private _totalUnused;
+    constructor(state: {
+        limitBalanceBufferFactor: number;
+        unusedBalance: TokenBalance[];
+        walletBalance: TokenBalance | null;
+        vaultBalance: TokenBalance | null;
+        extendedPositions: ExtendedPositionState[];
+        extendedBalance: ExtendedBalanceState | null;
+        vesuPoolStates: VesuPoolState[];
+    });
+    /**
+     * Initialise budget-tracking values from the current state snapshot.
+     * Must be called after state is populated and debt deltas are computed.
+     *
+     * Accounts for pendingDeposit:
+     * - pendingDeposit > 0: funds in transit TO Extended → increase effective Extended available-for-trade
+     * - pendingDeposit < 0: funds in transit FROM Extended → increase effective wallet balance
+     */
+    initBudget(): void;
+    get vaUsd(): number;
+    get walletUsd(): number;
+    get vaWalletUsd(): number;
+    get extAvailWithdraw(): number;
+    get extAvailUpnl(): number;
+    get extAvailTrade(): number;
+    get vesuBorrowCapacity(): number;
+    get totalUnused(): number;
+    get extPendingDeposit(): number;
+    spendVA(desired: number): number;
+    addToVA(amount: number): void;
+    spendWallet(desired: number): number;
+    addToWallet(amount: number): void;
+    spendVAWallet(desired: number): number;
+    private _updateExtAvailWithdraw;
+    private _updateExtAvailUpnl;
+    spendExtAvailTrade(desired: number): number;
+    spendExtAvailUpnl(desired: number): number;
+    addToExtAvailTrade(amount: 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 an Extended position's size after a lever route. Creates the position if new. */
+    applyExtendedExposureDelta(instrument: string, sizeDelta: Web3Number): void;
+    /**
+     * 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;
+}
+/**
+ * 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;
+    /**
+     * Reads the asset-token balance sitting idle in the vault allocator contract.
+     */
+    private _fetchVaultAllocatorBalance;
+    /**
+     * Merges the vault-allocator balance and wallet balances into a
+     * deduplicated array of TokenBalance entries keyed by token address.
+     *
+     * e.g. VA has USDC, wallet has USDC + USDC.e → returns
+     *   [{ token: USDC, amount: VA+wallet, usdValue: … },
+     *    { token: USDC.e, amount: wallet, usdValue: … }]
+     */
+    private _computeUnusedBalances;
+    /**
+     * Reads the operator wallet's balances for the asset token (USDC.e) and
+     * USDC.e (needed for route computation — P1 vs P2 decision for Extended deposits).
+     */
+    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,
+     * both reduced by the configured buffer percentage.
+     */
+    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).
+     */
+    private _classifyLtvVesu;
+    /**
+     * 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]
+     */
+    /** 2b. LTV Rebalance — Extended side */
+    /**
+     * 2b. LTV Rebalance — Extended side
+     *
+     * Triggered when Extended equity is below the required margin for current positions.
+     * Sources funds to Extended via VA/Wallet or Vesu borrow.
+     *
+     * Priority: 1) VA/Wallet → Extended  2) Vesu borrow → VA → Extended
+     */
+    private _classifyLtvExtended;
+    /**
+     * 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]
+     */
+    /**
+     * 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
+     */
     /**
-     * Uses vesu's multiple call to create leverage on LST
-     * Deposit amount is in LST
-     * @param params
+     * 3. New Deposits / Excess Funds
+     *
+     * Computes allocation split between Vesu and Extended, then sources
+     * funds and creates lever-increase routes.
+     *
+     * Fund flow (principle #3 — accumulate transfers, defer wait):
+     *   Phase A: fund Extended (wallet→ext, VA→ext, vesu-borrow→VA→ext)
+     *   Phase B: fund Vesu VA shortfall (wallet→VA, ext→wallet + wallet→VA)
+     *   Phase C: RETURN_TO_WAIT (if any transfer to Extended occurred)
+     *   Phase D: lever routes (VESU_MULTIPLY, EXTENDED_INCREASE) near each other (#4)
      */
-    getFundManagementCall(params: {
-        isDeposit: boolean;
-        leg1DepositAmount: Web3Number;
-    }): Promise<Call[] | null>;
-    getLSTUnderlyingTokenInfo(): TokenInfo;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
-    }>;
+    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;
+}
+
+declare class UsdcToUsdceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: BaseAdapterConfig;
+    private _approveProofReadableId;
+    private _swapProofReadableId;
+    private buildSwapLeafConfigs;
+    private buildSwapCalls;
+    constructor(config: BaseAdapterConfig);
+    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;
+    }[];
+    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
-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>[];
 
 /**
  * Transaction metadata that SDK generates and risk engine stores in DB.
@@ -2213,39 +3676,438 @@ interface TransactionResult<T = any> {
     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>;
 
-declare abstract class Operations {
-    abstract shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<TransactionResult[]>;
-    abstract shouldInvest(): Promise<{
-        shouldInvest: boolean;
-        vesuAmount: Web3Number;
-        extendedAmount: Web3Number;
-        extendedLeverage: number;
-        vesuLeverage: number;
-        debtAmountToBeRepaid: Web3Number;
-    }>;
+interface ExecutionConfig {
+    networkConfig: IConfig;
+    pricer: PricerBase;
+    vesuAdapter: VesuMultiplyAdapter;
+    vesuModifyPositionAdapter: VesuModifyPositionAdapter;
+    extendedAdapter: ExtendedAdapter;
+    avnuAdapter: AvnuAdapter;
+    usdcToUsdceAdapter: UsdcToUsdceAdapter;
+    usdceTransferAdapter: TokenTransferAdapter;
+    vaultAllocator: ContractAddr;
+    walletAddress: string;
+    wbtcToken: TokenInfo;
+    usdcToken: TokenInfo;
+    usdceToken: TokenInfo;
     /**
-     * Move assets between protocols.
-     * Returns transaction calls and metadata for DB tracking.
+     * Returns the strategy's merkle tree (built from all leaf adapters).
+     * Used to generate proofs for adapter manage calls.
      */
-    abstract moveAssets(params: {
-        from: string;
-        to: string;
+    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;
-        cycleType: CycleType;
-    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<TransactionResult>;
+    }) => Promise<Call>;
     /**
-     * Handle deposit operation.
-     * Returns transaction calls and metadata for DB tracking.
+     * Optional callback invoked on key execution lifecycle events.
+     * Use to persist state to DB, send alerts, etc.
      */
-    abstract handleDeposit(): Promise<TransactionResult<{
-        extendedAmountInBTC: Web3Number;
-    }>>;
+    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)
+     */
+    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.e 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.e 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.e 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;
+    /**
+     * 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.
+     */
+    private _executeExtendedDecreaseLever;
+    /**
+     * CRISIS_INCREASE_EXTENDED_MAX_LEVERAGE: Temporarily increase Extended
+     * leverage to the crisis maximum (e.g. 4x) to free margin.
+     */
+    private _executeCrisisIncreaseLeverage;
+    /**
+     * CRISIS_UNDO_EXTENDED_MAX_LEVERAGE: Revert Extended leverage back to
+     * the normal calculated level.
+     */
+    private _executeCrisisUndoLeverage;
+    /**
+     * 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;
     /**
-     * Handle withdrawal operation.
-     * Returns transaction calls and metadata for DB tracking.
+     * Creates a TransactionResult for a batch of on-chain calls.
+     * The caller is expected to send all calls in a single multicall transaction.
      */
-    abstract handleWithdraw(amount: Web3Number): Promise<TransactionResult[]>;
+    private _onChainBatchResult;
+    private _successResult;
+    private _failureResult;
 }
 
 interface VesuExtendedStrategySettings extends UniversalStrategySettings {
@@ -2258,80 +4120,76 @@ interface VesuExtendedStrategySettings extends UniversalStrategySettings {
     minimumWBTCDifferenceForAvnuSwap: number;
     walletAddress: string;
 }
-declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySettings> extends SVKStrategy<S> implements Operations {
+declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySettings> extends SVKStrategy<S> {
+    wbtcToken: TokenInfo;
+    usdcToken: TokenInfo;
+    usdceToken: TokenInfo;
+    readonly stateManager: ExtendedSVKVesuStateManager;
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
+    /**
+     * Extracts the required adapters from metadata and constructs the
+     * state manager used by shouldInvest / handleWithdraw.
+     */
+    private _initializeStateManager;
     getTag(): string;
+    /**
+     * Fetches current WBTC (collateral) and USDC (debt) prices from the pricer.
+     * Validates that both prices are finite and positive, throwing if not.
+     */
     getAssetPrices(): Promise<{
         collateralPrice: PriceInfo;
         debtPrice: PriceInfo;
     }>;
-    getUnusedBalanceUSDCE(): Promise<SingleTokenInfo>;
-    getUnusedBalanceWBTC(): Promise<SingleTokenInfo>;
-    getVesuAdapter(): Promise<VesuMultiplyAdapter | null>;
-    getAvnuAdapter(): Promise<AvnuAdapter | null>;
-    getExtendedAdapter(): Promise<ExtendedAdapter | null>;
-    moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<{
-        calls: Call[];
-        status: boolean;
-    }>;
-    shouldInvest(): Promise<{
-        shouldInvest: boolean;
-        vesuAmount: Web3Number;
-        extendedAmount: Web3Number;
-        extendedLeverage: number;
-        collateralPrice: number;
-        debtPrice: number;
-        vesuLeverage: number;
-        debtAmountToBeRepaid: Web3Number;
-    }>;
-    shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<TransactionResult[]>;
+    getVesuAdapter(): Promise<VesuMultiplyAdapter>;
+    getVesuModifyPositionAdapter(): Promise<VesuModifyPositionAdapter>;
+    getUsdceTransferAdapter(): Promise<TokenTransferAdapter>;
+    getAvnuAdapter(): Promise<AvnuAdapter>;
+    getExtendedAdapter(): Promise<ExtendedAdapter>;
+    getUsdcToUsdceAdapter(): Promise<UsdcToUsdceAdapter>;
     /**
-     * Helper method to create transaction result with metadata
+     * 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%)
      */
-    private createTransactionResult;
+    createExecutionService(opts?: {
+        onExecutionEvent?: ExecutionCallback;
+        extendedAcceptableSlippageBps?: number;
+        maxPriceDivergenceBps?: number;
+    }): Promise<ExecutionService>;
     /**
-     * This method is used to move assets between protocols
-     * @param params - The parameters for the move assets operation
-     * @param extendedAdapter - The extended adapter
-     * @param vesuAdapter - The vesu adapter
-     * @returns The transaction result
-     * If Extended amount is greater than amount of withdrawal from extended, then we need to open a long position
-     * so that the amount of withdrawal from extended is fullfilled
+     * 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.
      */
-    moveAssets(params: {
-        amount: Web3Number;
-        from: string;
-        to: string;
-        cycleType: CycleType;
-    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<TransactionResult>;
-    handleDeposit(): Promise<TransactionResult>;
-    /**
-     * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
-     * @param extendedAdapter - the extended adapter
-     * @param vesuAdapter - the vesu adapter
-     * @param avnuAdapter - the avnu adapter
-     * @param positionType - the position type (open or close)
-     * @returns true if the price difference is within the acceptable range, false otherwise
-     */
-    checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter, positionType: PositionTypeAvnuExtended): Promise<boolean>;
-    /**
-     * Handle the withdrawal of assets from the vault
-     * @param amount - the amount to withdraw in USDC
-     * @returns the calls to be executed and the status of the calls generated along with the metadata for the calls
-     */
-    handleWithdraw(amount: Web3Number): Promise<TransactionResult[]>;
     getAUM(): Promise<{
         net: SingleTokenInfo;
         prevAum: Web3Number;
         splits: PositionInfo[];
     }>;
-    processTransactionDataFromSDK(txnData: TransactionResult<any>[]): Promise<{
-        callsToBeExecutedFinal: Call[];
-        txnMetadata: TransactionMetadata[];
-    } | null>;
-    processTransactionMetadata(txnMetadata: TransactionMetadata[], extendedIntentFulfilled: boolean): Promise<TransactionMetadata[] | null>;
+    /**
+     * 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.
+     */
     getMaxBorrowableAmount(): Promise<Web3Number>;
+    /**
+     * 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.
+     */
     getVesuHealthFactors(): Promise<number[]>;
+    /**
+     * 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.
+     */
     netAPY(): Promise<{
         net: number;
         splits: {
@@ -2339,6 +4197,10 @@ declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySetti
             id: string;
         }[];
     }>;
+    /**
+     * Fetches the operator wallet's current holdings for USDC.e, USDC, and WBTC,
+     * returning each token's balance and USD value.
+     */
     getWalletHoldings(): Promise<{
         tokenInfo: TokenInfo;
         amount: Web3Number;
@@ -2386,6 +4248,7 @@ declare const VesuConfig: {
     readonly avnu: {
         readonly api: "https://starknet.api.avnu.fi/swap/v2/quotes";
     };
+    readonly targetLtv: 0.61;
     readonly minDebtForVesuRebalacing: number;
 };
 declare const AbisConfig: {
@@ -2680,17 +4543,19 @@ declare const AbisConfig: {
  */
 declare const returnFormattedAmount: (amount: number, toTokenDecimals: number) => string;
 /**
- * calculates the amount to distribute to Extend and Vesu
+ * 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: (amount: number, client: ExtendedWrapper, marketName: string, collateralPrice: number, debtPrice: number, collateralUnits: Web3Number, extendedPosition: Position[] | null) => Promise<{
-    vesu_amount: Web3Number;
-    extended_amount: Web3Number;
-    extended_leverage: number;
-    vesu_leverage: number;
-}>;
+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
@@ -2729,7 +4594,7 @@ declare const calculateExtendedLevergae: () => number;
  * @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) => {
+collateralPrice: number, isDeposit: boolean, targetLtv?: number) => {
     deltadebtAmountUnits: Web3Number;
     isIncrease: boolean;
 } | {
@@ -2771,7 +4636,7 @@ declare const calculateAmountDepositOnExtendedWhenIncurringLosses: (client: Exte
  * @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, targetHF?: number) => {
+declare const calculateWBTCAmountToMaintainLTV: (collateralAmount: Web3Number, debtAmount: Web3Number, debtPrice: number, maxLtv: number | undefined, collateralPrice: number) => {
     deltaCollateralAmountUnits: Web3Number;
 } | {
     deltaCollateralAmountUnits: null;
@@ -2784,8 +4649,7 @@ declare const calculateExposureDelta: (exposure_extended: number, exposure_vesu:
  * @returns {number} The delta percentage
  */
 declare const calculateBTCPriceDelta: (btcPrice: number, lastBtcPrice: number) => number;
-declare const calculateVesUPositionSizeGivenExtended: (extendedPositonValue: number, extendedHoldingAmount: Web3Number, collateralAmount: Web3Number, collateralPrice: number) => {
-    vesuAmountInUsd: string;
+declare const calculateVesUPositionSizeGivenExtended: (extendedPositonSize: number, extendedHoldingAmount: Web3Number, collateralAmount: Web3Number, extendedBtcPrice: number) => {
     vesuAmountInBTC: Web3Number;
     extendedAmountInBTC: Web3Number;
 };
@@ -2797,11 +4661,106 @@ declare const calculateVesUPositionSizeGivenExtended: (extendedPositonValue: num
  * @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: (maxLtv: number | undefined, existingVesuCollateral: Web3Number, existingVesuDebt: Web3Number, collateralPrice: number, debtPrice: number, targetHf?: number) => Web3Number | null;
+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>;
 
+/**
+ * Filter option definition
+ */
+interface FilterOption {
+    id: string;
+    label: string;
+    icon?: string;
+}
+/**
+ * Strategy filter metadata - defines what filters are available
+ */
+interface StrategyFilterMetadata {
+    assets: FilterOption[];
+    protocols: FilterOption[];
+    quickFilters: FilterOption[];
+}
+/**
+ * Strategy type enum
+ */
+declare enum StrategyType {
+    EKUBO_CL = "ekubo",
+    UNIVERSAL = "universal",
+    HYPER_LST = "hyper-lst",
+    VESU_REBALANCE = "vesu-rebalance",
+    SENSEI = "sensei"
+}
+/**
+ * Strategy metadata extracted from IStrategyMetadata
+ */
+interface StrategyMetadata {
+    id: string;
+    name: string;
+    type: StrategyType;
+    assets: string[];
+    protocols: string[];
+    tags: string[];
+    curator?: {
+        name: string;
+        logo: string;
+    };
+    isRetired: boolean;
+}
+/**
+ * Strategy registry entry
+ */
+interface StrategyRegistryEntry<T = any> {
+    metadata: IStrategyMetadata<T>;
+    type: StrategyType;
+}
+/**
+ * Build strategy registry from SDK strategies
+ */
+declare function buildStrategyRegistry(): StrategyRegistryEntry[];
+/**
+ * Get all strategy metadata from registry
+ */
+declare function getAllStrategyMetadata(): StrategyMetadata[];
+/**
+ * Get filter metadata - defines available filters and their options
+ */
+declare function getFilterMetadata(): StrategyFilterMetadata;
+/**
+ * Get live strategies (filter out retired)
+ */
+declare function getLiveStrategies(): StrategyRegistryEntry[];
+/**
+ * Get strategies by type
+ */
+declare function getStrategiesByType(type: StrategyType): StrategyRegistryEntry[];
+
+declare enum FactoryStrategyType {
+    UNIVERSAL = "UNIVERSAL",
+    EKUBO_CL = "EKUBO_CL",
+    HYPER_LST = "HYPER_LST",
+    VESU_REBALANCE = "VESU_REBALANCE",
+    SENSEI = "SENSEI"
+}
+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 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;
+/**
+ * Determines the strategy type from metadata by inspecting the additionalInfo structure
+ */
+declare function getStrategyTypeFromMetadata(metadata: IStrategyMetadata<any>): FactoryStrategyType;
+/**
+ * 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>;
+
 interface EkuboRouteNode {
     pool_key: {
         token0: string;
@@ -2828,14 +4787,23 @@ declare class EkuboQuoter {
     ENDPOINT: string;
     tokenMarketData: TokenMarketData;
     constructor(config: IConfig, pricer: PricerBase);
+    private _callQuoterApi;
     /**
-     *
-     * @param fromToken
-     * @param toToken
-     * @param amount Can be negative too, which would mean to get exact amount out
-     * @returns
+     * Given exactly `inputAmount` of `fromToken`, how much `toToken` do I receive?
+     * @param fromToken - address of the token being sold
+     * @param toToken - address of the token being bought
+     * @param inputAmount - must be positive (the amount of fromToken to sell)
+     * @returns EkuboQuote where `total_calculated` is the output amount (positive)
+     */
+    getQuoteExactInput(fromToken: string, toToken: string, inputAmount: Web3Number): Promise<EkuboQuote>;
+    /**
+     * To receive exactly `outputAmount` of `toToken`, how much `fromToken` must I provide?
+     * @param fromToken - address of the token being sold
+     * @param toToken - address of the token being bought
+     * @param outputAmount - must be positive (the desired amount of toToken to receive)
+     * @returns EkuboQuote where `total_calculated` is the required input amount (negative per Ekubo convention)
      */
-    getQuote(fromToken: string, toToken: string, amount: Web3Number, retry?: number): Promise<EkuboQuote>;
+    getQuoteExactOutput(fromToken: string, toToken: string, outputAmount: Web3Number): Promise<EkuboQuote>;
     getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number): Promise<number>;
     getLSTTrueExchangeRate(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number): Promise<number>;
     getSwapLimitAmount(fromToken: TokenInfo, toToken: TokenInfo, amount: Web3Number, max_slippage?: number): Promise<Web3Number>;
@@ -2865,6 +4833,7 @@ declare class Global {
     static getDefaultTokens(): TokenInfo[];
     static getTokens(): Promise<TokenInfo[]>;
     static assert(condition: any, message: string): void;
+    static getTokenInfoFromName(tokenName: string): Promise<TokenInfo>;
     static getTokenInfoFromAddr(addr: ContractAddr): Promise<TokenInfo>;
     static setGlobalCache(key: string, data: any, ttl?: number): void;
     static getGlobalCache<T>(key: string): T | null;
@@ -3033,7 +5002,7 @@ declare class PricerRedis extends Pricer {
     /** sets current local price in redis */
     private _setRedisPrices;
     /** Returns price from redis */
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
 }
 
 declare function getAPIUsingHeadlessBrowser(url: string): Promise<any>;
@@ -3060,6 +5029,7 @@ declare function executeDeployCalls(contractsInfo: DeployContractResult[], acc:
 declare function executeTransactions(calls: Call[], acc: Account, provider: RpcProvider, remarks?: string): Promise<{
     transaction_hash: string;
 }>;
+declare function myWaitForTransaction(transaction_hash: string, provider: RpcProvider, retry?: number): Promise<boolean>;
 declare const Deployer: {
     getAccount: typeof getAccount;
     myDeclare: typeof myDeclare;
@@ -3067,6 +5037,7 @@ declare const Deployer: {
     prepareMultiDeployContracts: typeof prepareMultiDeployContracts;
     executeDeployCalls: typeof executeDeployCalls;
     executeTransactions: typeof executeTransactions;
+    myWaitForTransaction: typeof myWaitForTransaction;
 };
 
 /**
@@ -3147,4 +5118,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 AccountInfo, type AdapterLeafType, AddressesConfig, type AllAccountsStore, type ApiResponse, type ApproveCallParams, type AssetOperation, AssetOperationStatus, AssetOperationType, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuSwapCallParams, AvnuWrapper, type Balance, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, type CancelOrderRequest, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, CycleType, 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, ExitType, ExtendedAdapter, type ExtendedAdapterConfig, type ExtendedApiResponse, ExtendedConfig, ExtendedWrapper, type ExtendedWrapperConfig, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type FundingRate, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type L2Config, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, type Market, type MarketStats, Midas, Network, type OpenOrder, OrderSide, OrderStatus, OrderStatusReason, OrderType, PRICE_ROUTER, 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 RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, type RiskFactorConfig, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SettlementSignature, type SignedWithdrawRequest, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, type StarkDebuggingOrderAmounts, type StarkSettlement, Store, type StoreConfig, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, TimeInForce, type TokenAmount, type TokenInfo, TokenMarketData, type TradingConfig, type TransactionMetadata, type TransactionResult, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, type UniversalStrategySettings, UnusedBalanceAdapter, type UnusedBalanceAdapterConfig, type UpdateLeverageRequest, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, VesuConfig, type VesuDefiSpringRewardsCallParams, VesuExtendedMultiplierStrategy, type VesuExtendedStrategySettings, VesuExtendedTestStrategies, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, Web3Number, type WithdrawParams, type WithdrawRequest, ZkLend, _riskFactor, assert, calculateAmountDepositOnExtendedWhenIncurringLosses, calculateAmountDistribution, calculateAmountDistributionForWithdrawal, calculateBTCPriceDelta, calculateDebtAmount, calculateDebtReductionAmountForWithdrawal, calculateDeltaDebtAmount, calculateExposureDelta, calculateExtendedLevergae, calculatePositionToCloseToWithdrawAmount, calculateVesUPositionSizeGivenExtended, calculateVesuLeverage, calculateWBTCAmountToMaintainLTV, extensionMap, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getFAQs, getInvestmentSteps, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, returnFormattedAmount, toBigInt };
+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, type CancelOrderRequest, CaseCategory, CaseId, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, type CrisisBorrowRoute, type CrisisExtendedLeverRoute, CycleType, 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, 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, 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, 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 };