@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.50

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 { Uint256, RpcProvider, BlockIdentifier, Call, Contract, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import BigNumber from 'bignumber.js';
 import React, { ReactNode } from 'react';
+import { Quote, AvnuOptions } from '@avnu/avnu-sdk';
 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,14 +27,18 @@ 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> {
     static fromWei(weiNumber: string | number, decimals: number): Web3Number;
+    static fromNumber(number: number, decimals: number): Web3Number;
+    static fromUint256(uint256Value: Uint256): Web3Number;
 }
 
 /**
@@ -54,6 +58,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",
@@ -71,6 +102,13 @@ interface RiskFactor {
     weight: number;
     reason?: string;
 }
+type PriceMethod = 'AvnuApi' | 'Coinbase' | 'Coinmarketcap' | 'Ekubo' | 'Avnu';
+declare enum TokenIndexingType {
+    PEGGED = "pegged",
+    INDEXER = "indexer",
+    LST_SCRIPT = "lstScript",
+    IGNORE = "ignore"
+}
 interface TokenInfo {
     name: string;
     symbol: string;
@@ -81,6 +119,9 @@ interface TokenInfo {
     displayDecimals: number;
     priceProxySymbol?: string;
     priceCheckAmount?: number;
+    priceMethod?: PriceMethod;
+    dontPrice?: boolean;
+    indexingType: TokenIndexingType;
 }
 declare enum Network {
     mainnet = "mainnet",
@@ -97,6 +138,62 @@ interface IProtocol {
     name: string;
     logo: string;
 }
+interface ICurator {
+    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",
+    TVA = "Troves Value Averaging"
+}
+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",
+    ROLE_BASED_ACCESS = "Role Based Access"
+}
+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 +203,82 @@ 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 {
+    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[];
+}
+interface StrategyApyHistoryUIConfig {
+    showApyHistory?: boolean;
+    noApyHistoryMessage?: string;
+}
+interface FeeBps {
+    performanceFeeBps: number;
+}
 /**
  * @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;
+    /**
+     * Optional UI sort priority. Higher shows earlier.
+     * Intended for pinning flagship parent vaults (e.g. BTC above STRK).
+     */
+    priority?: number;
+    /**
+     * Optional UI config for the variant intro popup (strategy page).
+     * Should be identical across strategies that share the same `parentId`.
+     */
+    variantIntro?: {
+        title: string;
+        description: string;
+    };
     address: ContractAddr;
     launchBlock: number;
     type: "ERC4626" | "ERC721" | "Other";
+    vaultType: {
+        type: VaultType;
+        description: string;
+    };
     depositTokens: TokenInfo[];
     protocols: IProtocol[];
     auditUrl?: string;
-    maxTVL: Web3Number;
     risk: {
         riskFactor: RiskFactor[];
         netRisk: number;
         notARisks: RiskType[];
     };
     apyMethodology?: string;
+    realizedApyMethodology?: string;
+    feeBps?: FeeBps;
     additionalInfo: T;
     contractDetails: {
         address: ContractAddr;
@@ -140,11 +293,41 @@ interface IStrategyMetadata<T> {
     }[];
     docs?: string;
     investmentSteps: string[];
-    curator?: {
-        name: string;
-        logo: string;
-    };
+    curator?: ICurator;
     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;
+    apyHistoryUIConfig?: StrategyApyHistoryUIConfig;
+    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;
+    }>;
+    parentId?: string;
+    parentName?: string;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -157,6 +340,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 +357,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;
@@ -180,7 +386,9 @@ declare const Protocols: {
     EKUBO: IProtocol;
     AVNU: IProtocol;
     VAULT: IProtocol;
+    TROVES: IProtocol;
 };
+declare const UnwrapLabsCurator: ICurator;
 
 interface ILendingMetadata {
     name: string;
@@ -234,6 +442,27 @@ declare abstract class Initializable {
     waitForInitilisation(): Promise<void>;
 }
 
+/**
+ * Polls Avnu impulse tokens API and keeps USD prices in memory for configured tokens.
+ * Price timestamp is set when each poll request completes.
+ */
+declare class PricerAvnuApi extends PricerBase {
+    protected prices: {
+        [key: string]: PriceInfo;
+    };
+    readonly refreshInterval = 15000;
+    readonly staleTime: number;
+    private pollTimer;
+    private loading;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    start(): void;
+    stop(): void;
+    isStale(timestamp: Date): boolean;
+    hasPrice(tokenSymbol: string): boolean;
+    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    protected _loadPrices(): Promise<void>;
+}
+
 interface PriceInfo {
     price: number;
     timestamp: Date;
@@ -244,8 +473,9 @@ declare class Pricer extends PricerBase {
     };
     refreshInterval: number;
     staleTime: number;
+    protected readonly avnuApiPricer: PricerAvnuApi;
     protected methodToUse: {
-        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap';
+        [tokenSymbol: string]: PriceMethod;
     };
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -258,11 +488,15 @@ 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>;
+    _getPrice(token: TokenInfo): Promise<number>;
+    protected _getMethodsToTry(token: TokenInfo): PriceMethod[];
+    protected _tryPriceMethod(token: TokenInfo, method: PriceMethod): Promise<number>;
+    _getPriceAvnuApi(token: TokenInfo): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
     _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
+    _getAvnuPrice(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
     _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
 }
 
@@ -270,7 +504,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 {
@@ -280,296 +514,356 @@ interface CacheData$1 {
 }
 declare class CacheClass {
     readonly cache: Map<string, CacheData$1>;
+    isCacheEnabled: boolean;
     setCache(key: string, data: any, ttl?: number): void;
     getCache<T>(key: string): T | null;
     isCacheValid(key: string): boolean;
+    disableCache(): void;
+    enableCache(): void;
 }
 
-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 SingleActionAmount {
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
 }
-interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
-    format: 'standard-v1';
-    leafEncoding: ValueType[];
+interface SingleTokenInfo extends SingleActionAmount {
+    usdValue: number;
 }
-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 APYInfo {
+    net: number;
+    splits: {
+        apy: number;
+        id: string;
+    }[];
 }
-
-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 DualActionAmount {
+    token0: SingleActionAmount;
+    token1: SingleActionAmount;
 }
-interface DepositParams {
-    amount: Web3Number;
+interface DualTokenInfo {
+    usdValue: number;
+    token0: SingleTokenInfo;
+    token1: SingleTokenInfo;
 }
-interface WithdrawParams {
-    amount: Web3Number;
+type StrategyInputMode = "single" | "dual";
+type InputModeFromAction<T> = T extends DualActionAmount ? "dual" : "single";
+interface NetAPYSplit {
+    apy: number;
+    id: string;
 }
-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 NetAPYDetails {
+    net: number;
+    splits: NetAPYSplit[];
 }
-interface SupportedPosition {
-    asset: TokenInfo;
-    isDebt: boolean;
+type UserPositionCardSubValueColor = "default" | "positive" | "negative" | "info";
+interface UserPositionCard {
+    title: string;
+    value: string;
+    tooltip?: string;
+    subValue?: string;
+    subValueColor?: UserPositionCardSubValueColor;
 }
-interface BaseAdapterConfig {
-    baseToken: TokenInfo;
-    supportedPositions: SupportedPosition[];
-    networkConfig: IConfig;
-    pricer: PricerBase;
-    vaultAllocator: ContractAddr;
-    vaultAddress: ContractAddr;
+interface UserPositionCardsInput {
+    user: ContractAddr;
+    investmentFlows?: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>;
+    usualTimeToEarnings?: string | null;
+    usualTimeToEarningsDescription?: string | null;
 }
-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);
+interface CacheData {
+    timestamp: number;
+    ttl: number;
+    data: any;
+}
+declare class BaseStrategy<TVLInfo, DepositActionInfo, WithdrawActionInfo = DepositActionInfo> extends CacheClass {
+    readonly config: IConfig;
+    readonly cache: Map<string, CacheData>;
+    private readonly _depositInputMode;
+    private readonly _withdrawInputMode;
+    constructor(config: IConfig, inputModes?: {
+        depositInputMode?: InputModeFromAction<DepositActionInfo>;
+        withdrawInputMode?: InputModeFromAction<WithdrawActionInfo>;
+    });
+    depositInputMode(): InputModeFromAction<DepositActionInfo>;
+    withdrawInputMode(): InputModeFromAction<WithdrawActionInfo>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<TVLInfo>;
+    getTVL(): Promise<TVLInfo>;
+    depositCall(amountInfo: DepositActionInfo, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: WithdrawActionInfo, receiver: ContractAddr, owner: ContractAddr, isMaxWithdraw?: boolean): Promise<Call[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | string | NetAPYDetails>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]>;
+    getMaxTVL(): Promise<Web3Number>;
+    protected formatTokenAmountForCard(amount: Web3Number, tokenInfo: TokenInfo): string;
+    protected formatPercentForCard(value: number): string;
+    protected formatUSDForCard(value: number): string;
+    protected getSubValueColorFromSignedNumber(value: number): UserPositionCardSubValueColor;
+    /**
+     * Calculate lifetime earnings for a user based on provided data from client
+     * Formula: lifetimeEarnings = currentValue + totalWithdrawals - totalDeposits
+     *
+     * @param userTVL - The user's current TVL (SingleTokenInfo with amount, usdValue, tokenInfo)
+     * @param investmentFlows - Array of investment flow transactions from client
+     * @returns Object containing lifetime earnings, current value, and total deposits/withdrawals
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): {
+        tokenInfo: SingleTokenInfo;
+        lifetimeEarnings: Web3Number;
+        currentValue: Web3Number;
+        totalDeposits: Web3Number;
+        totalWithdrawals: Web3Number;
+    };
+}
+
+/**
+ * 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);
     /**
-     * Loop through all supported positions and return amount, usd value, remarks and apy for each
+     * 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)
      */
-    getPositions(): Promise<PositionInfo[]>;
+    getAPY(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to compute APY 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 getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    getPrice(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to fetch amount for a given supported position
+     * 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
      */
-    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    getTruePrice(tokenInfo: TokenInfo): Promise<number>;
     /**
-     * Implemented by child adapters to calculate maximum deposit positions
-     * @param amount Optional amount in baseToken to deposit
+     * 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 maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo>;
     /**
-     * Implemented by child adapters to calculate maximum withdraw positions
+     * Check if a token is supported for APY data
+     * @param tokenInfo The token to check
+     * @returns True if the token has APY data available
      */
-    abstract maxWithdraw(): Promise<PositionInfo>;
+    isAPYSupported(tokenInfo: TokenInfo): boolean;
     /**
-     * Uses pricer to convert an amount of an asset to USD value
+     * 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 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;
-    }[];
+    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>;
     /**
-     * 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, minAmount?: Web3Number): 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,27 +871,268 @@ 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[]>;
+    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, _isMaxWithdraw?: boolean): 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, isMaxWithdraw?: boolean): Promise<Call[]>;
     rebalanceCall(newBounds: EkuboBounds, swapParams: SwapInfo): Call[];
     handleUnusedCall(swapParams: SwapInfo): Call[];
     handleFeesCall(): Call[];
-    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m'): Promise<{
+    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m' | '6m', range?: {
+        startTimestamp?: number;
+        endTimestamp?: number;
+    }): Promise<{
         summary: DualTokenInfo;
         history: FeeHistory[];
     }>;
     netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Ekubo CL Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
+    /**
+     * Calculates realized APY based on TVL per share growth, always valued in USDC.
+     * This is a vault-level metric (same for all users) and works for all strategies,
+     * regardless of quote asset configuration.
+     */
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
     feeBasedAPY(timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
     /**
      * Calculates assets before and now in a given token of TVL per share to observe growth
      * @returns {Promise<number>} The weighted average APY across all pools
      */
-    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<APYInfo>;
+    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>;
@@ -652,7 +1187,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 +1207,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 +1218,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 +1246,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,806 +1296,709 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
  */
 declare const EkuboCLVaultStrategies: IStrategyMetadata<CLVaultStrategySettings>[];
 
-interface VesuPoolsInfo {
-    pools: any[];
-    isErrorPoolsAPI: boolean;
-}
-declare enum VesuAmountType {
-    Delta = 0,
-    Target = 1
-}
-declare enum VesuAmountDenomination {
-    Native = 0,
-    Assets = 1
-}
-interface i257 {
-    abs: Web3Number;
-    is_negative: boolean;
-}
-interface VesuAmount {
-    amount_type: VesuAmountType;
-    denomination: VesuAmountDenomination;
-    value: i257;
-}
-interface VesuModifyPositionCallParams {
-    collateralAmount: VesuAmount;
-    debtAmount: VesuAmount;
+interface SenseiVaultSettings {
+    mainToken: TokenInfo;
+    secondaryToken: TokenInfo;
+    targetHfBps: number;
+    feeBps: number;
 }
-interface VesuDefiSpringRewardsCallParams {
-    amount: Web3Number;
-    proofs: string[];
-}
-interface VesuAdapterConfig {
-    poolId: ContractAddr;
-    collateral: TokenInfo;
-    debt: TokenInfo;
-    vaultAllocator: ContractAddr;
-    id: string;
-}
-type InterestRateConfig = {
-    target_utilization: bigint;
-    zero_utilization_rate: bigint;
-    target_rate_percent: bigint;
-    min_target_utilization: bigint;
-    max_target_utilization: bigint;
-    rate_half_life: bigint;
-    min_full_utilization_rate: bigint;
-    max_full_utilization_rate: bigint;
-};
-interface TokenAmount {
-    token: ContractAddr;
-    amount: Web3Number;
-}
-interface Swap {
-    route: RouteNode[];
-    token_amount: TokenAmount;
-}
-interface RouteNode {
-    pool_key: EkuboPoolKey;
-    sqrt_ratio_limit: Web3Number;
-    skip_ahead: Web3Number;
-}
-interface IncreaseLeverParams {
-    pool_id: ContractAddr;
-    collateral_asset: ContractAddr;
-    debt_asset: ContractAddr;
-    user: ContractAddr;
-    add_margin: Web3Number;
-    margin_swap: Swap[];
-    margin_swap_limit_amount: Web3Number;
-    lever_swap: Swap[];
-    lever_swap_limit_amount: Web3Number;
-}
-interface DecreaseLeverParams {
-    pool_id: ContractAddr;
-    collateral_asset: ContractAddr;
-    debt_asset: ContractAddr;
-    user: ContractAddr;
-    sub_margin: Web3Number;
-    recipient: ContractAddr;
-    lever_swap: Swap[];
-    lever_swap_limit_amount: Web3Number;
-    lever_swap_weights: Web3Number[];
-    withdraw_swap: Swap[];
-    withdraw_swap_limit_amount: Web3Number;
-    withdraw_swap_weights: Web3Number[];
-    close_position: boolean;
-}
-interface VesuMultiplyCallParams {
-    increaseParams?: Omit<IncreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset'>;
-    decreaseParams?: Omit<DecreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset' | 'recipient'>;
-    isIncrease: boolean;
-}
-interface VesuModifyDelegationCallParams {
-    delegation: boolean;
-}
-declare const VesuPools: {
-    Genesis: ContractAddr;
-    Re7xSTRK: ContractAddr;
-    Re7xBTC: ContractAddr;
-    Re7USDCPrime: ContractAddr;
-};
-declare const extensionMap: {
-    [key: string]: ContractAddr;
-};
-declare function getVesuSingletonAddress(vesuPool: ContractAddr): {
-    addr: ContractAddr;
-    isV2: boolean;
-};
-declare class VesuAdapter extends CacheClass {
-    VESU_MULTIPLY_V1: ContractAddr;
-    VESU_MULTIPLY: ContractAddr;
-    config: VesuAdapterConfig;
-    networkConfig: IConfig | undefined;
-    pricer: PricerBase | undefined;
-    constructor(config: VesuAdapterConfig);
-    getVesuModifyDelegationCall: (params: VesuModifyDelegationCallParams) => ManageCall;
-    formatAmountTypeEnum(amountType: VesuAmountType): CairoCustomEnum;
-    formatAmountDenominationEnum(denomination: VesuAmountDenomination): CairoCustomEnum;
-    getVesuSingletonContract(config: IConfig, poolId: ContractAddr): {
-        contract: Contract;
-        isV2: boolean;
-    };
-    getDebtCap(config: IConfig): Promise<Web3Number>;
-    getCurrentDebtUtilisationAmount(config: IConfig): Promise<Web3Number>;
-    getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number): Promise<Web3Number>;
-    getLTVConfig(config: IConfig, blockNumber?: BlockIdentifier): Promise<number>;
-    getPositions(config: IConfig, blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
-    getCollateralization(config: IConfig, blockNumber?: BlockIdentifier): Promise<Omit<VaultPosition, 'amount'>[]>;
-    getAssetPrices(): Promise<{
-        collateralTokenAmount: Web3Number;
-        collateralUSDAmount: number;
-        collateralPrice: number;
-        debtTokenAmount: Web3Number;
-        debtUSDAmount: number;
-        debtPrice: number;
-        ltv: 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, blockIdentifier?: BlockIdentifier): Promise<SingleTokenInfo>;
+    getTVL(): Promise<SingleTokenInfo>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr, _isMaxWithdraw?: boolean): Promise<Call[]>;
+    getPositionInfo(): Promise<{
+        collateralXSTRK: Web3Number;
+        collateralUSDValue: Web3Number;
+        debtSTRK: Web3Number;
+        debtUSDValue: Web3Number;
+        xSTRKPrice: number;
+        collateralInSTRK: number;
     }>;
-    getHealthFactor(blockNumber?: BlockIdentifier): Promise<number>;
-    static getVesuPools(retry?: number): Promise<VesuPoolsInfo>;
-    fullUtilizationRate(interestRateConfig: InterestRateConfig, timeDelta: bigint, utilization: bigint, fullUtilizationRate: bigint): bigint;
+    getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
+    getSettings: () => Promise<starknet.CallResult>;
     /**
-     * Calculates new interest rate per second and next full utilization rate.
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Sensei Vault strategy
      */
-    calculateInterestRate(interestRateConfig: InterestRateConfig, utilization: bigint, timeDelta: bigint, lastFullUtilizationRate: bigint): {
-        newRatePerSecond: bigint;
-        nextFullUtilizationRate: bigint;
-    };
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
+    netAPY(): Promise<number>;
     /**
-     * Calculates utilization given a specific rate per second.
-     * This is an inverse function of the piecewise interest rate formula above.
+     * 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.
      */
-    getMaxUtilizationGivenRatePerSecond(interestRateConfig: InterestRateConfig, ratePerSecond: bigint, timeDelta: bigint, last_full_utilization_rate: bigint): bigint;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]>;
 }
+declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
 
-interface VesuSupplyOnlyAdapterConfig extends BaseAdapterConfig {
-    vTokenContract: ContractAddr;
-}
-declare class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: VesuSupplyOnlyAdapterConfig;
-    readonly tokenMarketData: TokenMarketData;
-    constructor(config: VesuSupplyOnlyAdapterConfig);
-    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;
-    }[];
-    getDepositAdapter(): AdapterLeafType<DepositParams>;
-    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    getHealthFactor(): Promise<number>;
+interface YoloVaultSettings {
+    startDate: string;
+    expiryDate: string;
+    mainToken: TokenInfo;
+    secondaryToken: TokenInfo;
+    totalEpochs: number;
+    minEpochDurationSeconds: number;
+    spendingLevels: YoloSpendingLevel[];
+    feeBps: number;
+    /** When true, base token is ERC-4626 (e.g. vUSDC); amounts for TVL / user info use `convert_to_assets` into `baseUnderlying`. */
+    isBaseERC4626?: boolean;
+    /** When true, second token is ERC-4626 (e.g. xSTRK); amounts use `convert_to_assets` into `secondUnderlying`. */
+    isSecondERC4626?: boolean;
+    /** Required when `isBaseERC4626` is true (e.g. USDC). */
+    baseUnderlying?: TokenInfo;
+    /** Required when `isSecondERC4626` is true (e.g. STRK / WBTC for xSTRK / xWBTC). */
+    secondUnderlying?: TokenInfo;
+}
+interface YoloSpendingLevel {
+    minPrice?: number;
+    maxPrice?: number;
+    spendPercent: number;
+}
+interface UserYoloInfo {
+    shares: bigint;
+    claimable_second_tokens: bigint;
+    base_token_balance: bigint;
+    base_token_consumed: bigint;
+    base_consumed_last_index: bigint;
+    second_token_last_index: bigint;
+    second_token_balance: bigint;
+}
+interface YoloVaultStatus {
+    current_epoch: bigint;
+    total_epochs: bigint;
+    remaining_base: bigint;
+    total_second_tokens: bigint;
+    global_second_token_index: bigint;
+    cumulative_spend_index: bigint;
+    total_shares: bigint;
+    base_token_assets_per_share: bigint;
+}
+interface YoloSettings {
+    base_token: bigint;
+    second_token: bigint;
+    total_epochs: bigint;
+    min_time_per_epoch: bigint;
+    max_spend_units_per_epoch: bigint;
+    base_token_assets_per_share: bigint;
+    oracle: bigint;
+}
+type YoloErc4626RuntimeConfig = {
+    isBaseERC4626: boolean;
+    isSecondERC4626: boolean;
+    baseUnderlying?: TokenInfo;
+    secondUnderlying?: TokenInfo;
+};
+declare class YoLoVault extends BaseStrategy<DualTokenInfo, SingleActionAmount, DualActionAmount> {
+    readonly address: ContractAddr;
+    readonly metadata: IStrategyMetadata<YoloVaultSettings>;
+    readonly pricer: PricerBase;
+    /** Resolves to a `Contract` built from `provider.getClassAt` at the vault address (no checked-in vault ABI). */
+    readonly contract: Promise<Contract>;
+    readonly primaryToken: TokenInfo;
+    readonly secondaryToken: TokenInfo;
+    readonly erc4626: YoloErc4626RuntimeConfig;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<YoloVaultSettings>);
+    /** Underlying (or base token) used for pricing / swap sell leg when base is ERC-4626. */
+    tokenForPrimaryPricing(): TokenInfo;
+    /** Underlying (or second token) for price ratios when second leg is ERC-4626 (e.g. STRK for xSTRK). */
+    tokenForSecondaryPricing(): TokenInfo;
+    private primaryAmountDecimals;
+    private secondaryAmountDecimals;
+    private convertWrapperSharesToUnderlying;
+    private getNormalizedUserInfo;
+    private resolveWithdrawRequest;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getTVL(): Promise<DualTokenInfo>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    getVaultStatus(): Promise<YoloVaultStatus>;
+    matchInputAmounts(amountInfo: DualActionAmount, user: ContractAddr): Promise<DualActionAmount>;
+    withdrawCall(amountInfo: DualActionAmount, receiver: ContractAddr, owner: ContractAddr, isMaxWithdraw?: boolean): Promise<Call[]>;
+    netAPY(): Promise<number | string | NetAPYDetails>;
+    getSwapAmounts(spendUnits: Web3Number): Promise<{
+        grossSpend: Web3Number;
+        netSpend: Web3Number;
+        isReadyForNextSwap: boolean;
+    }>;
+    getSettings: () => Promise<YoloSettings>;
+    getMaxTVL(): Promise<Web3Number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
 }
+declare const YoloVaultStrategies: IStrategyMetadata<YoloVaultSettings>[];
 
-interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
-    poolId: ContractAddr;
-    collateral: TokenInfo;
-    debt: TokenInfo;
-    targetHealthFactor: number;
-    minHealthFactor: number;
-    quoteAmountToFetchPrice: Web3Number;
+interface LeveledLogMethod {
+    (message: string, ...meta: any[]): void;
+    (message: any): void;
 }
-declare class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: VesuMultiplyAdapterConfig;
-    readonly vesuAdapter: VesuAdapter;
-    readonly tokenMarketData: TokenMarketData;
-    constructor(config: VesuMultiplyAdapterConfig);
-    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
-    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
-    maxBorrowableAPY(): Promise<number>;
-    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;
-    }[];
-    getDepositAdapter(): AdapterLeafType<DepositParams>;
-    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    private getMultiplyCallCalldata;
-    private getLeverParams;
-    private getWithdrawalCalldata;
-    formatMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams): {
-        action: CairoCustomEnum;
-    };
-    getHealthFactor(): Promise<number>;
-    getNetAPY(): Promise<number>;
+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;
 
-/**
- * TypeScript type definitions for Extended Exchange API
- * Based on Python SDK models from x10.perpetual
- */
-declare enum OrderSide {
-    BUY = "BUY",
-    SELL = "SELL"
-}
-declare enum TimeInForce {
-    GTT = "GTT",
-    IOC = "IOC",
-    FOK = "FOK"
-}
-declare enum OrderType {
-    LIMIT = "LIMIT",
-    CONDITIONAL = "CONDITIONAL",
-    MARKET = "MARKET",
-    TPSL = "TPSL"
-}
-declare enum OrderStatus {
-    UNKNOWN = "UNKNOWN",
-    NEW = "NEW",
-    UNTRIGGERED = "UNTRIGGERED",
-    PARTIALLY_FILLED = "PARTIALLY_FILLED",
-    FILLED = "FILLED",
-    CANCELLED = "CANCELLED",
-    EXPIRED = "EXPIRED",
-    REJECTED = "REJECTED"
-}
-declare enum OrderStatusReason {
-    UNKNOWN = "UNKNOWN",
-    NONE = "NONE",
-    UNKNOWN_MARKET = "UNKNOWN_MARKET",
-    DISABLED_MARKET = "DISABLED_MARKET",
-    NOT_ENOUGH_FUNDS = "NOT_ENOUGH_FUNDS",
-    NO_LIQUIDITY = "NO_LIQUIDITY",
-    INVALID_FEE = "INVALID_FEE",
-    INVALID_QTY = "INVALID_QTY",
-    INVALID_PRICE = "INVALID_PRICE",
-    INVALID_VALUE = "INVALID_VALUE",
-    UNKNOWN_ACCOUNT = "UNKNOWN_ACCOUNT",
-    SELF_TRADE_PROTECTION = "SELF_TRADE_PROTECTION",
-    POST_ONLY_FAILED = "POST_ONLY_FAILED",
-    REDUCE_ONLY_FAILED = "REDUCE_ONLY_FAILED",
-    INVALID_EXPIRE_TIME = "INVALID_EXPIRE_TIME",
-    POSITION_TPSL_CONFLICT = "POSITION_TPSL_CONFLICT",
-    INVALID_LEVERAGE = "INVALID_LEVERAGE",
-    PREV_ORDER_NOT_FOUND = "PREV_ORDER_NOT_FOUND",
-    PREV_ORDER_TRIGGERED = "PREV_ORDER_TRIGGERED",
-    TPSL_OTHER_SIDE_FILLED = "TPSL_OTHER_SIDE_FILLED",
-    PREV_ORDER_CONFLICT = "PREV_ORDER_CONFLICT",
-    ORDER_REPLACED = "ORDER_REPLACED",
-    POST_ONLY_MODE = "POST_ONLY_MODE",
-    REDUCE_ONLY_MODE = "REDUCE_ONLY_MODE",
-    TRADING_OFF_MODE = "TRADING_OFF_MODE"
-}
-declare enum PositionSide {
-    LONG = "LONG",
-    SHORT = "SHORT"
-}
-declare enum ExitType {
-    TRADE = "TRADE",
-    LIQUIDATION = "LIQUIDATION",
-    ADL = "ADL"
-}
-declare enum AssetOperationType {
-    DEPOSIT = "DEPOSIT",
-    WITHDRAWAL = "WITHDRAWAL",
-    TRANSFER = "TRANSFER"
-}
-declare enum AssetOperationStatus {
-    PENDING = "PENDING",
-    COMPLETED = "COMPLETED",
-    FAILED = "FAILED"
-}
-interface SettlementSignature {
-    r: string;
-    s: string;
-}
-interface StarkSettlement {
-    signature: SettlementSignature;
-    stark_key: string;
-    collateral_position: string;
-}
-interface StarkDebuggingOrderAmounts {
-    collateral_amount: string;
-    fee_amount: string;
-    synthetic_amount: string;
-}
-interface PlacedOrder {
-    id: number;
-    external_id: string;
-}
-interface OpenOrder {
-    id: number;
-    account_id: number;
-    external_id: string;
-    market: string;
-    type: OrderType;
-    side: OrderSide;
-    status: OrderStatus;
-    status_reason?: OrderStatusReason;
-    price: string;
-    average_price?: string;
-    qty: string;
-    filled_qty?: string;
-    reduce_only: boolean;
-    post_only: boolean;
-    payed_fee?: string;
-    created_time: number;
-    updated_time: number;
-    expiry_time?: number;
-}
-interface Position {
-    id: number;
-    accountId: number;
-    market: string;
-    side: PositionSide;
-    leverage: string;
-    size: string;
-    value: string;
-    openPrice: string;
-    markPrice: string;
-    liquidationPrice?: string;
-    unrealisedPnl: string;
-    realisedPnl: string;
-    tpPrice?: string;
-    slPrice?: string;
-    adl?: number;
-    createdAt: number;
-    updatedAt: number;
-}
-interface PositionHistory {
-    id: number;
-    account_id: number;
-    market: string;
-    side: PositionSide;
-    leverage: string;
-    size: string;
-    open_price: string;
-    exit_type?: ExitType;
-    exit_price?: string;
-    realised_pnl: string;
-    created_time: number;
-    closed_time?: number;
-}
-interface Balance {
-    collateral_name: string;
-    balance: string;
-    equity: string;
-    availableForTrade: string;
-    availableForWithdrawal: string;
-    unrealisedPnl: string;
-    initialMargin: string;
-    marginRatio: string;
-    updatedTime: number;
-}
-interface RiskFactorConfig {
-    upper_bound: string;
-    risk_factor: string;
-}
-interface MarketStats {
-    daily_volume: string;
-    daily_volume_base: string;
-    daily_price_change: string;
-    daily_low: string;
-    daily_high: string;
-    last_price: string;
-    ask_price: string;
-    bid_price: string;
-    mark_price: string;
-    index_price: string;
-    funding_rate: string;
-    next_funding_rate: number;
-    open_interest: string;
-    open_interest_base: string;
-}
-interface TradingConfig {
-    min_order_size: string;
-    min_order_size_change: string;
-    min_price_change: string;
-    max_market_order_value: string;
-    max_limit_order_value: string;
-    max_position_value: string;
-    max_leverage: string;
-    max_num_orders: number;
-    limit_price_cap: string;
-    limit_price_floor: string;
-    risk_factor_config: RiskFactorConfig[];
-}
-interface L2Config {
-    type: string;
-    collateral_id: string;
-    collateral_resolution: number;
-    synthetic_id: string;
-    synthetic_resolution: number;
-}
-interface Market {
-    name: string;
-    asset_name: string;
-    asset_precision: number;
-    collateral_asset_name: string;
-    collateral_asset_precision: number;
-    active: boolean;
-    market_stats: MarketStats;
-    trading_config: TradingConfig;
-    l2_config: L2Config;
-}
-interface AssetOperation {
-    id: number;
-    type: AssetOperationType;
-    status: AssetOperationStatus;
-    amount: string;
-    asset: string;
-    created_time: number;
-    updated_time: number;
-    description?: string;
-    transactionHash?: string;
-}
-interface CreateOrderRequest {
-    market_name: string;
-    amount: string;
-    price: string;
-    side: OrderSide;
-    post_only?: boolean;
-    previous_order_id?: number;
-    external_id?: string;
-    time_in_force?: TimeInForce;
-}
-interface WithdrawRequest {
-    amount: string;
-    asset?: string;
-}
-interface SignedWithdrawRequest {
-    recipient: string;
-    position_id: number;
-    amount: number;
-    expiration: number;
-    salt: number;
-}
-interface CancelOrderRequest {
-    order_id: number;
-}
-interface ApiResponse<T> {
-    success: boolean;
-    message: string;
-    data: T;
-}
-interface ExtendedApiResponse<T> {
-    status: 'OK' | 'ERROR';
-    message: string;
-    data: T;
-}
-interface ExtendedWrapperConfig {
-    baseUrl: string;
-    apiKey?: string;
-    timeout?: number;
-    retries?: number;
+interface LeafData {
+    id: bigint;
+    readableId: string;
+    data: bigint[];
 }
-interface UpdateLeverageRequest {
-    leverage: string;
-    market: string;
+interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+    format: 'standard-v1';
+    leafEncoding: ValueType[];
 }
-interface FundingRate {
-    m: string;
-    f: string;
-    t: number;
+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>;
 }
 
 /**
- * ExtendedWrapper - TypeScript wrapper for Extended Exchange API
- * Provides a clean interface to interact with the Extended Exchange trading API
+ * 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;
 
-declare class ExtendedWrapper {
-    private baseUrl;
-    private apiKey?;
-    private timeout;
-    private retries;
-    constructor(config: ExtendedWrapperConfig);
-    /**
-     * Make HTTP request with retry logic and error handling
-     */
-    private makeRequest;
-    /**
-     * Create a new order on Extended Exchange
-     */
-    createOrder(request: CreateOrderRequest): Promise<ExtendedApiResponse<PlacedOrder>>;
-    /**
-     * Get all markets
-     */
-    getMarkets(marketNames?: string): Promise<ExtendedApiResponse<Market[]>>;
-    /**
-    *
-    * @param orderId - The ID of the order to get
-    * @returns The order
-    */
-    getOrderByOrderId(orderId: string): Promise<ExtendedApiResponse<OpenOrder>>;
-    /**
-     * Get market statistics for a specific market
-     */
-    getMarketStatistics(marketName: string): Promise<ExtendedApiResponse<MarketStats>>;
-    /**
-     * Get current trading positions
-     */
-    getPositions(marketNames?: string): Promise<ExtendedApiResponse<Position[]>>;
-    /**
-     * Get account balance and holdings
-     */
-    getHoldings(): Promise<ExtendedApiResponse<Balance>>;
-    /**
-     * Initiate a withdrawal from Extended Exchange
-     */
-    withdraw(request: WithdrawRequest): Promise<ExtendedApiResponse<number>>;
-    /**
-     * Create and sign a withdrawal request hash
-     */
-    signWithdrawalRequest(request: SignedWithdrawRequest): Promise<ExtendedApiResponse<{
-        withdraw_request_hash: string;
-        signature: {
-            r: string;
-            s: string;
-        };
-    }>>;
-    /**
-     * Cancel an existing order
-     */
-    cancelOrder(request: CancelOrderRequest): Promise<ExtendedApiResponse<{}>>;
+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;
+}
+
+declare class HealthFactorMath {
+    static getCollateralRequired(debtAmount: Web3Number, debtPrice: number, targetHF: number, maxLTV: number, collateralPrice: number, collateralTokenInfo: TokenInfo): Web3Number;
+    static getMinCollateralRequiredOnLooping(debtAmount: Web3Number, debtPrice: number, targetHF: number, maxLTV: number, collateralPrice: number, collateralTokenInfo: TokenInfo): Web3Number;
+    static getHealthFactor(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, debtAmount: Web3Number, debtPrice: number): number;
+    static getMaxDebtAmountOnLooping(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, targetHF: number, debtPrice: number, debtTokenInfo: TokenInfo): Web3Number;
+    static getMaxDebtAmount(collateralAmount: Web3Number, collateralPrice: number, maxLTV: number, targetHF: number, debtPrice: number, debtTokenInfo: TokenInfo): Web3Number;
+    static calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number, targetHF: number, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, collateralTokenInfo: TokenInfo, debtTokenInfo: TokenInfo) => {
+        deltadebtAmountUnits: null;
+    } | {
+        deltadebtAmountUnits: Web3Number;
+    };
+}
+
+type RequiredFields<T> = {
+    [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);
     /**
-     * Get all open orders
+     * Loop through all supported positions and return amount, usd value, remarks and apy for each
      */
-    getOpenOrders(marketName?: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
+    getPositions(): Promise<PositionInfo[]>;
     /**
-     * Update leverage on the market
-     * @param request
-     * @returns
+     * Implemented by child adapters to compute APY for a given supported position
      */
-    updateLeverage(request: UpdateLeverageRequest): Promise<ExtendedApiResponse<{}>>;
+    protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
     /**
-     * Get asset operations with optional filtering
+     * Implemented by child adapters to fetch amount for a given supported position
      */
-    getAssetOperations(options?: {
-        id?: number;
-        operationsType?: AssetOperationType[];
-        operationsStatus?: AssetOperationStatus[];
-        startTime?: number;
-        endTime?: number;
-        cursor?: number;
-        limit?: number;
-    }): Promise<ExtendedApiResponse<AssetOperation[]>>;
+    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
     /**
-     * Health check endpoint
+     * Implemented by child adapters to calculate maximum deposit positions
+     * @param amount Optional amount in baseToken to deposit
      */
-    healthCheck(): Promise<ExtendedApiResponse<MarketStats>>;
+    abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     /**
-     * Convenience method to create a buy order
+     * Implemented by child adapters to calculate maximum withdraw positions
      */
-    createBuyOrder(marketName: string, amount: string, price: string, options?: {
-        postOnly?: 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
-    */
-    getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>>;
+    abstract maxWithdraw(): Promise<PositionInfo>;
     /**
-     * Convenience method to create a sell order
+     * Uses pricer to convert an amount of an asset to USD value
      */
-    createSellOrder(marketName: string, amount: string, price: string, options?: {
-        postOnly?: boolean;
-        previousOrderId?: number;
-        externalId?: string;
-        timeInForce?: TimeInForce;
-    }): Promise<ExtendedApiResponse<PlacedOrder>>;
+    protected getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number>;
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
     /**
-     * Get positions for a specific market
+     * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
      */
-    getPositionsForMarket(marketName: string): Promise<ExtendedApiResponse<Position[]>>;
+    protected abstract _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
     /**
-     * Get open orders for a specific market
+     * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
      */
-    getOpenOrdersForMarket(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
+    protected abstract _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
     /**
-     * Cancel order by ID (convenience method)
+     * Returns deposit leaf adapter using configured proof id
      */
-    cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>>;
+    getDepositLeaf(): AdapterLeafType<DepositParams>;
     /**
-     * Get order history for a specific market
-     * @param marketName - The name of the market to get order history for
-     * @returns The order history for the specified market
+     * Returns withdraw leaf adapter using configured proof id
      */
-    getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
+    getWithdrawLeaf(): AdapterLeafType<WithdrawParams>;
     /**
-     * Withdraw USDC (convenience method)
+     * Implementor must provide deposit call
+     * @param params
      */
-    withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number>>;
+    abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
     /**
-     * Get funding rates for a specific market
-     * @param marketName - The name of the market to get funding rates for
-     * @returns The funding rates for the specified market
+     * Implementor must provide withdraw call
+     * @param params
      */
-    getFundingRates(marketName: string, side: string): Promise<ExtendedApiResponse<FundingRate[]>>;
+    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 Route {
-    token_from: string;
-    token_to: string;
-    exchange_address: string;
-    percent: number;
-    additional_swap_params: string[];
+interface FlashloanCallParams {
+    amount: Web3Number;
+    data: bigint[];
 }
-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[];
+interface ApproveCallParams {
+    amount: Web3Number;
 }
-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 AvnuSwapCallParams {
+    props: SwapInfo;
 }
-
-interface AvnuAdapterConfig extends BaseAdapterConfig {
-    baseUrl: string;
-    avnuContract: ContractAddr;
-    slippage: number;
+interface CommonAdapterConfig {
+    id: string;
+    vaultAddress: ContractAddr;
+    vaultAllocator: ContractAddr;
+    manager: ContractAddr;
+    asset: ContractAddr;
 }
-declare class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: AvnuAdapterConfig;
-    protected avnuWrapper: AvnuWrapper;
-    constructor(config: AvnuAdapterConfig);
-    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;
+declare class CommonAdapter {
+    config: CommonAdapterConfig;
+    constructor(config: CommonAdapterConfig);
+    protected constructSimpleLeafData(params: {
         id: string;
-    }[];
-    protected _getLegacySwapLeaf(): {
         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;
-        id: string;
-    }[];
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    getSwapCallData(quote: Quote): Promise<bigint[][]>;
-    getHealthFactor(): Promise<number>;
-    fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
-    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>;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    }[]>;
+    getBringLiquidityCall(proofReadableId: string): GenerateCallFn<ApproveCallParams>;
 }
 
-interface ExtendedAdapterConfig extends BaseAdapterConfig {
-    vaultIdExtended: number;
-    extendedContract: ContractAddr;
-    extendedBackendUrl: string;
-    extendedApiKey: string;
-    extendedTimeout: number;
-    extendedRetries: number;
-    extendedBaseUrl: string;
-    extendedMarketName: string;
-    extendedPrecision: number;
-    avnuAdapter: AvnuAdapter;
-}
-declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: ExtendedAdapterConfig;
-    readonly client: ExtendedWrapper;
-    constructor(config: ExtendedAdapterConfig);
-    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;
-    }[];
-    getSwapFromLegacyLeaf(): AdapterLeafType<DepositParams>;
-    protected _getSwapFromLegacyLeaf(): {
-        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[]>;
-    getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): {
-        proofs: string[][];
-        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
+interface VesuPoolsInfo {
+    pools: any[];
+    isErrorPoolsAPI: boolean;
+}
+declare enum VesuAmountType {
+    Delta = 0,
+    Target = 1
+}
+declare enum VesuAmountDenomination {
+    Native = 0,
+    Assets = 1
+}
+interface i257 {
+    abs: Web3Number;
+    is_negative: boolean;
+}
+interface VesuAmount {
+    amount_type: VesuAmountType;
+    denomination: VesuAmountDenomination;
+    value: i257;
+}
+interface VesuModifyPositionCallParams {
+    collateralAmount: VesuAmount;
+    debtAmount: VesuAmount;
+}
+interface VesuDefiSpringRewardsCallParams {
+    amount: Web3Number;
+    proofs: string[];
+}
+interface VesuAdapterConfig {
+    poolId: ContractAddr;
+    collateral: TokenInfo;
+    debt: TokenInfo;
+    vaultAllocator: ContractAddr;
+    id: string;
+}
+type InterestRateConfig = {
+    target_utilization: bigint;
+    zero_utilization_rate: bigint;
+    target_rate_percent: bigint;
+    min_target_utilization: bigint;
+    max_target_utilization: bigint;
+    rate_half_life: bigint;
+    min_full_utilization_rate: bigint;
+    max_full_utilization_rate: bigint;
+};
+interface TokenAmount {
+    token: ContractAddr;
+    amount: Web3Number;
+}
+interface Swap {
+    route: RouteNode[];
+    token_amount: TokenAmount;
+}
+interface RouteNode {
+    pool_key: EkuboPoolKey;
+    sqrt_ratio_limit: Web3Number;
+    skip_ahead: Web3Number;
+}
+interface IncreaseLeverParams {
+    pool_id: ContractAddr;
+    collateral_asset: ContractAddr;
+    debt_asset: ContractAddr;
+    user: ContractAddr;
+    add_margin: Web3Number;
+    margin_swap: Swap[];
+    margin_swap_limit_amount: Web3Number;
+    lever_swap: Swap[];
+    lever_swap_limit_amount: Web3Number;
+}
+interface DecreaseLeverParams {
+    pool_id: ContractAddr;
+    collateral_asset: ContractAddr;
+    debt_asset: ContractAddr;
+    user: ContractAddr;
+    sub_margin: Web3Number;
+    recipient: ContractAddr;
+    lever_swap: Swap[];
+    lever_swap_limit_amount: Web3Number;
+    lever_swap_weights: Web3Number[];
+    withdraw_swap: Swap[];
+    withdraw_swap_limit_amount: Web3Number;
+    withdraw_swap_weights: Web3Number[];
+    close_position: boolean;
+}
+interface VesuMultiplyCallParams {
+    increaseParams?: Omit<IncreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset'>;
+    decreaseParams?: Omit<DecreaseLeverParams, 'user' | 'pool_id' | 'collateral_asset' | 'debt_asset' | 'recipient'>;
+    isIncrease: boolean;
+}
+interface VesuModifyDelegationCallParams {
+    delegation: boolean;
+}
+declare const VesuPools: {
+    Genesis: ContractAddr;
+    Re7xSTRK: ContractAddr;
+    Re7xBTC: ContractAddr;
+    Re7USDCPrime: ContractAddr;
+    Prime: ContractAddr;
+    Re7STRK: ContractAddr;
+};
+declare const VesuPoolMetadata: {
+    [VesuPools.Genesis.address]: {
+        name: string;
     };
-    getSwapFromLegacyCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    withdrawFromExtended(amount: Web3Number): Promise<boolean>;
-    getHealthFactor(): Promise<number>;
-    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<{
-        status: boolean;
-        bid: Web3Number;
-        ask: Web3Number;
+    [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;
+};
+declare function getVesuSingletonAddress(vesuPool: ContractAddr): {
+    addr: ContractAddr;
+    isV2: boolean;
+};
+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);
+    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): {
+        contract: Contract;
+        isV2: boolean;
+    };
+    getDebtCap(config: IConfig): Promise<Web3Number>;
+    getCurrentDebtUtilisationAmount(config: IConfig): 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'>[]>;
+    getAssetPrices(): Promise<{
+        collateralTokenAmount: Web3Number;
+        collateralUSDAmount: number;
+        collateralPrice: number;
+        debtTokenAmount: Web3Number;
+        debtUSDAmount: number;
+        debtPrice: number;
+        ltv: number;
     }>;
-    createOrder(leverage: string, btcAmount: number, side: OrderSide, attempt?: number, maxAttempts?: number): Promise<{
-        position_id: string;
-        btc_exposure: string;
-    } | null>;
-    createExtendedPositon(client: ExtendedWrapper, marketName: string, amount: string, price: string, side: OrderSide): Promise<{
-        position_id: string;
-    } | null>;
-    getDepositOrWithdrawalStatus(orderId: number | string, operationsType: AssetOperationType): Promise<boolean>;
+    getHealthFactor(blockNumber?: BlockIdentifier): Promise<number>;
+    static getVesuPools(retry?: number): Promise<VesuPoolsInfo>;
+    fullUtilizationRate(interestRateConfig: InterestRateConfig, timeDelta: bigint, utilization: bigint, fullUtilizationRate: bigint): bigint;
+    /**
+     * Calculates new interest rate per second and next full utilization rate.
+     */
+    calculateInterestRate(interestRateConfig: InterestRateConfig, utilization: bigint, timeDelta: bigint, lastFullUtilizationRate: bigint): {
+        newRatePerSecond: bigint;
+        nextFullUtilizationRate: bigint;
+    };
+    /**
+     * Calculates utilization given a specific rate per second.
+     * This is an inverse function of the piecewise interest rate formula above.
+     */
+    getMaxUtilizationGivenRatePerSecond(interestRateConfig: InterestRateConfig, ratePerSecond: bigint, timeDelta: bigint, last_full_utilization_rate: bigint): bigint;
 }
 
-declare const SIMPLE_SANITIZER: ContractAddr;
-declare const EXTENDED_SANITIZER: ContractAddr;
-declare const AVNU_LEGACY_SANITIZER: ContractAddr;
-declare const SIMPLE_SANITIZER_V2: ContractAddr;
-declare const VESU_V2_MODIFY_POSITION_SANITIZER: ContractAddr;
-declare const SIMPLE_SANITIZER_VESU_V1_DELEGATIONS: ContractAddr;
-declare const PRICE_ROUTER: ContractAddr;
-declare const AVNU_MIDDLEWARE: ContractAddr;
-declare const AVNU_EXCHANGE: ContractAddr;
-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 function toBigInt(value: string | number): bigint;
-
-interface UnusedBalanceAdapterConfig extends BaseAdapterConfig {
+interface VesuSupplyOnlyAdapterConfig extends BaseAdapterConfig {
+    vTokenContract: ContractAddr;
 }
-declare class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: UnusedBalanceAdapterConfig;
+declare class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: VesuSupplyOnlyAdapterConfig;
     readonly tokenMarketData: TokenMarketData;
-    constructor(config: UnusedBalanceAdapterConfig);
-    protected getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    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>;
     maxWithdraw(): Promise<PositionInfo>;
@@ -1571,479 +2016,367 @@ declare class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawPa
         sanitizer: ContractAddr;
         id: string;
     }[];
-    getHealthFactor(): Promise<number>;
+    getDepositAdapter(): AdapterLeafType<DepositParams>;
+    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
     getDepositCall(params: DepositParams): Promise<ManageCall[]>;
     getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
 
-interface SingleActionAmount {
-    tokenInfo: TokenInfo;
+interface VesuDepositParams {
+    amount: Web3Number;
+    marginSwap?: {
+        marginToken: TokenInfo;
+    };
+    leverSwap?: {
+        exactOutput?: Web3Number;
+    };
+}
+interface VesuWithdrawParams {
     amount: Web3Number;
+    withdrawSwap?: {
+        outputToken: TokenInfo;
+    };
 }
-interface SingleTokenInfo extends SingleActionAmount {
-    usdValue: number;
+interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
+    poolId: ContractAddr;
+    collateral: TokenInfo;
+    debt: TokenInfo;
+    marginToken: TokenInfo;
+    targetHealthFactor: number;
+    minHealthFactor: number;
+    quoteAmountToFetchPrice: Web3Number;
+    minimumVesuMovementAmount: number;
+    maxSlippage?: number;
 }
-interface APYInfo {
-    net: number;
-    splits: {
-        apy: number;
+declare class VesuMultiplyAdapter extends BaseAdapter<VesuDepositParams, VesuWithdrawParams> {
+    readonly config: VesuMultiplyAdapterConfig;
+    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 | null>;
+    maxBorrowableAPY(): Promise<number>;
+    private _computeMax;
+    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;
     }[];
+    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>;
 }
-interface DualActionAmount {
-    token0: SingleActionAmount;
-    token1: SingleActionAmount;
+
+interface VesuModifyPositionDepositParams {
+    amount: Web3Number;
+    debtAmount?: Web3Number;
 }
-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>;
+interface VesuModifyPositionWithdrawParams {
+    amount: Web3Number;
+    debtAmount?: Web3Number;
 }
-
-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>;
+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>;
     /**
-     * @description Get the health factor of the user
-     * - Considers all tokens for collateral and debt
+     * Simulates a deposit of `depositAmount` collateral and returns how much
+     * debt (STRK) would be incrementally borrowed to reach the target LTV.
+     * Used upstream to size the AVNU swap call in the same transaction batch.
      */
-    get_health_factor(user: ContractAddr): Promise<number>;
-    getPositionsSummary(user: ContractAddr): Promise<{
-        collateralUSD: number;
-        debtUSD: number;
-    }>;
+    getExpectedDepositDebtDelta(depositAmount: Web3Number): Promise<Web3Number>;
     /**
-     * @description Get the token-wise collateral and debt positions of the user
-     * @param user Contract address of the user
-     * @returns Promise<ILendingPosition[]>
+     * Simulates a withdrawal of `withdrawAmount` collateral and returns the
+     * incremental debt delta needed to keep the target health factor.
+     * Positive means borrow, negative means repay.
      */
-    getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
+    getExpectedWithdrawDebtDelta(withdrawAmount: Web3Number): Promise<Web3Number>;
 }
 
-declare class PricerFromApi extends PricerBase {
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-    getPriceFromMyAPI(tokenSymbol: string): Promise<{
-        price: number;
-        timestamp: Date;
-    }>;
-}
+declare const SIMPLE_SANITIZER: ContractAddr;
+declare const SVK_SIMPLE_SANITIZER: ContractAddr;
+declare const EXTENDED_SANITIZER: ContractAddr;
+declare const AVNU_LEGACY_SANITIZER: ContractAddr;
+declare const SIMPLE_SANITIZER_V2: ContractAddr;
+declare const VESU_V2_MODIFY_POSITION_SANITIZER: ContractAddr;
+declare const SIMPLE_SANITIZER_VESU_V1_DELEGATIONS: ContractAddr;
+declare const PRICE_ROUTER: ContractAddr;
+declare const AVNU_MIDDLEWARE: ContractAddr;
+declare const AVNU_EXCHANGE: ContractAddr;
+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;
 
-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;
+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 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;
-    }>;
+/**
+ * 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: TokenTransferAdapterConfig);
+    private _idBase;
+    private _depositCallProofReadableId;
+    private _withdrawCallProofReadableId;
+    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: DepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
 
-interface PoolProps {
-    pool_id: ContractAddr;
-    max_weight: number;
-    v_token: ContractAddr;
+interface AvnuDepositParams extends DepositParams {
+    minAmount?: Web3Number;
 }
-interface Change {
-    pool_id: ContractAddr;
-    changeAmt: Web3Number;
-    finalAmt: Web3Number;
-    isDeposit: boolean;
-}
-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;
+interface AvnuWithdrawParams extends WithdrawParams {
+    minAmount?: Web3Number;
 }
-/**
- * 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> {
-    /** 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>;
-    /** 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
-     */
-    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<{
-        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>;
+interface AvnuAdapterConfig extends BaseAdapterConfig {
+    baseUrl: string;
+    avnuContract: ContractAddr;
+    slippage: number;
+    minimumExtendedPriceDifferenceForSwapOpen: number;
+    maximumExtendedPriceDifferenceForSwapClosing: number;
+}
+declare class AvnuAdapter extends BaseAdapter<AvnuDepositParams, AvnuWithdrawParams> {
+    readonly config: AvnuAdapterConfig;
+    protected avnuWrapper: AvnuWrapper;
+    lastSwapPriceInfo: SwapPriceInfo | null;
+    private _depositApproveProofReadableId;
+    private _depositSwapProofReadableId;
+    private _withdrawApproveProofReadableId;
+    private _withdrawSwapProofReadableId;
+    private buildSwapLeafConfigs;
+    private buildSwapCalls;
+    constructor(config: AvnuAdapterConfig);
+    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
+    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    maxWithdraw(): Promise<PositionInfo>;
+    protected _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getLegacySwapLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getDepositCall(params: AvnuDepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: AvnuWithdrawParams): Promise<ManageCall[]>;
+    getSwapCallData(quote: Quote): Promise<bigint[][]>;
+    getHealthFactor(): Promise<number>;
+    fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
+}
+
+/** Public Troves strategies feed (APY + metadata). Override in config for tests. */
+declare const DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
+interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
     /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * On-chain Troves / SVK strategy vault: ERC-4626-style `deposit` / `withdraw` on the underlying asset,
+     * plus `due_assets_from_owner` for redemption NFT value still owed to an owner.
      */
-    netAPYGivenPools(pools: PoolInfoFull[]): Promise<number>;
+    strategyVault: ContractAddr;
     /**
-     * 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
+     * Troves API `strategies[].id` string (e.g. `hyper_xstrk`). Used to resolve APY from the public JSON feed.
      */
-    getRebalancedPositions(_pools?: PoolInfoFull[]): Promise<{
-        changes: never[];
-        finalPools: never[];
-        isAnyPoolOverMaxWeight?: undefined;
-    } | {
-        changes: Change[];
-        finalPools: PoolInfoFull[];
-        isAnyPoolOverMaxWeight: boolean;
-    }>;
+    trovesStrategyId: 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
+     * Address whose vault **share** balance and **pending** redemption assets are measured.
+     * Defaults to `vaultAllocator` when omitted (typical STRKFarm vault wiring).
      */
-    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[]>;
+    positionOwner?: ContractAddr;
+    /** Optional APY endpoint (defaults to {@link DEFAULT_TROVES_STRATEGIES_API}). */
+    trovesStrategiesApiUrl?: string;
     /**
-     * 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
+     * Optional redeem request NFT contract address. When provided, pending assets are calculated
+     * using `getPendingAssetsFromOwnerNFTMethod` instead of `due_assets_from_owner`.
      */
-    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
-        vToken: ContractAddr;
-        fee: Web3Number;
-    }>>;
+    redeemRequestNFT?: ContractAddr;
 }
 /**
- * Represents the Vesu Rebalance Strategies.
+ * Universal adapter for **Starknet Vault Kit (SVK)** style Troves strategies:
+ * approve underlying → `deposit(assets, receiver)`, and `withdraw(assets, receiver, owner)` on the strategy vault.
+ *
+ * **Position sizing** (underlying asset, same decimals as `baseToken`):
+ * - Liquid: `convert_to_assets(balance_of(positionOwner))` on the strategy vault (vault shares).
+ * - Pending redemptions: `due_assets_from_owner(positionOwner)` on the same vault (NFT / queue claims not yet settled).
+ *
+ * **APY**: Fetched from Troves public API by `trovesStrategyId` (numeric `apy` field; non-numeric marketing values fall back to `0`).
  */
-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;
-    }>;
-    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: {
+declare class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: SvkTrovesAdapterConfig;
+    constructor(config: SvkTrovesAdapterConfig);
+    /** Owner used for share balance + `due_assets_from_owner`. */
+    private _positionOwner;
+    /**
+     * Proof readable IDs must stay ≤ 31 chars (Cairo short string). We derive a short ASCII suffix from
+     * `strategyVault` address so multiple SVK adapters in one tree stay distinct.
+     */
+    private _proofSuffix;
+    private _depositApproveProofReadableId;
+    private _depositCallProofReadableId;
+    private _withdrawCallProofReadableId;
+    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount | null>;
+    getPendingAssetsFromOwner(owner?: ContractAddr, decimals?: number): Promise<Web3Number>;
+    /**
+     * Get pending assets from owner by scanning redeem request NFTs.
+     * This method iterates backwards through NFT IDs to find all pending redemptions for a specific owner.
+     *
+     * @param redeemRequestNFT - The redeem request NFT contract address
+     * @param owner - The owner address to check for pending redemptions (defaults to positionOwner)
+     * @param decimals - Token decimals for conversion (defaults to baseToken decimals)
+     * @returns Total pending assets from all NFTs owned by the specified address
+     */
+    getPendingAssetsFromOwnerNFTMethod(redeemRequestNFT: ContractAddr, owner?: ContractAddr, decimals?: number): Promise<Web3Number>;
+    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    maxWithdraw(): Promise<PositionInfo>;
+    protected _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
         id: string;
-        adapter: BaseAdapter<DepositParams, WithdrawParams>;
     }[];
+    protected _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getDepositAdapter(): AdapterLeafType<DepositParams>;
+    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
+    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getHealthFactor(): Promise<number>;
 }
-declare enum AUMTypes {
-    FINALISED = "finalised",
-    DEFISPRING = "defispring"
-}
-declare enum UNIVERSAL_MANAGE_IDS {
-    FLASH_LOAN = "flash_loan_init",
-    VESU_LEG1 = "vesu_leg1",
-    VESU_LEG2 = "vesu_leg2",
-    APPROVE_TOKEN1 = "approve_token1",
-    APPROVE_TOKEN2 = "approve_token2",
-    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
-    BRING_LIQUIDITY = "bring_liquidity",
-    DEFISPRING_REWARDS = "defispring_rewards",
-    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
-    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
+
+declare enum LSTPriceType {
+    ENDUR_PRICE = "ENDUR_PRICE",
+    AVNU_PRICE = "AVNU_PRICE"
 }
-declare function getContractDetails(settings: UniversalStrategySettings & {
-    aumOracle?: ContractAddr;
-}): {
-    address: ContractAddr;
-    name: string;
-}[];
 
 /**
  * Base class for all SVK (Starknet Vault Kit) strategies.
@@ -2067,11 +2400,21 @@ 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, isMaxWithdraw?: boolean): Promise<Call[]>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<SingleTokenInfo>;
     /**
      * 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, additionalParams?: Record<string, any>): Promise<Call>;
     /**
      * Bridges liquidity from the vault allocator back to the vault.
      * Note: This function is common for any SVK strategy.
@@ -2079,6 +2422,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.
@@ -2095,52 +2443,240 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
      */
     getMerkleRoot(): string;
     /**
-     * Combines proofs and manage calls into a single Starknet call.
-     * Note: This function is common for any SVK strategy.
+     * Combines proofs and manage calls into a single Starknet call.
+     * Note: This function is common for any SVK strategy.
+     */
+    getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call;
+    /**
+     * Creates a call to set the merkle root on the manager contract.
+     * Note: This function is common for any SVK strategy.
+     */
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    /**
+     * Returns a tag for logging purposes.
+     * Should be overridden by subclasses to provide strategy-specific tags.
+     */
+    abstract getTag(): string;
+    /**
+     * Returns the positions in the vault.
+     * @returns An array of VaultPosition objects representing the positions in the vault.
+     */
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getHealthFactors(): Promise<number[]>;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    getTVL(): Promise<SingleTokenInfo>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
+    getPrevAUM(): Promise<Web3Number>;
+    maxDepositables(): Promise<PositionInfo[]>;
+    maxWithdrawables(): Promise<PositionInfo[]>;
+    getMaxTVL(): Promise<Web3Number>;
+}
+
+interface UniversalManageCall {
+    proofs: string[];
+    manageCall: ManageCall;
+    step: UNIVERSAL_MANAGE_IDS;
+}
+interface UniversalStrategySettings {
+    vaultAddress: ContractAddr;
+    manager: ContractAddr;
+    vaultAllocator: ContractAddr;
+    redeemRequestNFT: ContractAddr;
+    aumOracle: ContractAddr;
+    redemptionRouter?: ContractAddr;
+    leafAdapters: LeafAdapterFn<any>[];
+    adapters: {
+        id: string;
+        adapter: BaseAdapter<DepositParams, WithdrawParams>;
+    }[];
+    targetHealthFactor: number;
+    minHealthFactor: number;
+}
+declare enum AUMTypes {
+    FINALISED = "finalised",
+    DEFISPRING = "defispring",
+    BTCFI = "btcfi"
+}
+declare enum PositionTypeAvnuExtended {
+    OPEN = "open",
+    CLOSE = "close"
+}
+declare class UniversalStrategy<S extends UniversalStrategySettings> extends SVKStrategy<S> {
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
+    getMerkleTree(): StandardMerkleTree;
+    getMerkleRoot(): string;
+    getProofs<T>(id: string): {
+        proofs: string[];
+        callConstructor: GenerateCallFn<T>;
+    };
+    getAdapter(id: string): BaseAdapter<any, any>;
+    asset(): TokenInfo;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr, isMaxWithdraw?: boolean): Promise<Call[]>;
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
+    }>;
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    protected getUnusedBalanceAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    private computeAPY;
+    /**
+       * Calculates 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>;
+    getVesuMultiplyAdapter(): VesuMultiplyAdapter;
+    getVesuModifyPositionAdapter(): VesuModifyPositionAdapter;
+    /**
+     * Legacy helper for retired Evergreen flows. New integrations should use
+     * getVesuMultiplyAdapter / getVesuModifyPositionAdapter and BaseAdapter deposit/withdraw leaves.
      */
-    getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call;
+    getVesuAdapters(): VesuAdapter[];
+    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
     /**
-     * Creates a call to set the merkle root on the manager contract.
-     * Note: This function is common for any SVK strategy.
+     * Compatibility helper: SVKStrategy's `getManageCall` expects proof-groups.
+     * We derive proof-groups from each manageCall's `proofReadableId`.
      */
-    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    protected getManageCallFromManageCalls(manageCalls: ManageCall[]): Call;
+    getVesuModifyPositionCalls(params: {
+        isLeg1: boolean;
+        isDeposit: boolean;
+        depositAmount: Web3Number;
+        debtAmount: Web3Number;
+    }): UniversalManageCall[];
+    getTag(): string;
     /**
-     * Returns a tag for logging purposes.
-     * Should be overridden by subclasses to provide strategy-specific tags.
+     * Gets LST APR for the strategy's underlying asset from Endur API
+     * @returns Promise<number> The LST APR (not divided by 1e18)
      */
-    abstract getTag(): string;
+    getLSTAPR(address: ContractAddr): Promise<number>;
+    getVesuHealthFactors(blockNumber?: BlockIdentifier): Promise<number[]>;
+    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
+    private getNewHealthFactor;
     /**
-     * Returns the positions in the vault.
-     * @returns An array of VaultPosition objects representing the positions in the vault.
+     *
+     * @param vesuAdapter
+     * @param currentHf
+     * @param isDeposit if true, attempt by adding collateral, else by repaying
+     * @returns
      */
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getHealthFactors(): Promise<number[]>;
-    netAPY(): Promise<{
-        net: number;
-        splits: {
-            apy: number;
-            id: string;
-        }[];
+    private getLegRebalanceAmount;
+    getVesuModifyPositionCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    getHarvestCall(): Promise<{
+        call: Call;
+        reward: Web3Number;
+        tokenInfo: TokenInfo;
     }>;
-    getPrevAUM(): Promise<Web3Number>;
-    maxDepositables(): Promise<PositionInfo[]>;
-    maxWithdrawables(): Promise<PositionInfo[]>;
+    getRebalanceCall(params: {
+        isLeg1toLeg2: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
+}
+declare enum UNIVERSAL_MANAGE_IDS {
+    FLASH_LOAN = "flash_loan_init",
+    VESU_LEG1 = "vesu_leg1",
+    VESU_LEG2 = "vesu_leg2",
+    APPROVE_TOKEN1 = "approve_token1",
+    APPROVE_TOKEN2 = "approve_token2",
+    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
+    BRING_LIQUIDITY = "bring_liquidity",
+    DEFISPRING_REWARDS = "defispring_rewards",
+    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
+    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
 }
+declare enum UNIVERSAL_ADAPTER_IDS {
+    VESU_MULTIPLY = "vesu_multiply",
+    VESU_MODIFY = "vesu_modify",
+    AVNU = "avnu"
+}
+declare function getContractDetails(settings: UniversalStrategySettings & {
+    aumOracle?: ContractAddr;
+}): {
+    address: ContractAddr;
+    name: string;
+}[];
+declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
 
 interface HyperLSTStrategySettings extends UniversalStrategySettings {
-    borrowable_assets: TokenInfo[];
+    borrowable_assets: {
+        tokenInfo: TokenInfo;
+        poolId: ContractAddr;
+    }[];
     underlyingToken: TokenInfo;
     quoteAmountToFetchPrice: Web3Number;
     targetHealthFactor: number;
     minHealthFactor: number;
     aumOracle: ContractAddr;
+    adapterIds?: {
+        /** VesuMultiplyAdapter for underlying-matched debt (first matching borrowable pool) */
+        primaryMultiply: string;
+        multiply: Record<string, string>;
+        modify: Record<string, string>;
+    };
 }
 declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
     private quoteAmountToFetchPrice;
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
     getTag(): string;
+    private getAdapterById;
+    getVesuMultiplyAdapterByKey(key: string): VesuMultiplyAdapter;
     getVesuSameTokenAdapter(): VesuMultiplyAdapter;
-    getVesuAdapters(): VesuMultiplyAdapter[];
+    getVesuMultiplyAdapters(): VesuMultiplyAdapter[];
+    getRewardsAUM(_prevAum: Web3Number): Promise<Web3Number>;
+    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
@@ -2151,11 +2687,73 @@ declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
         leg1DepositAmount: Web3Number;
     }): Promise<Call[] | null>;
     getLSTUnderlyingTokenInfo(): TokenInfo;
-    getAUM(): Promise<{
+    getLSTAPR(_address: ContractAddr): Promise<number>;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
+    }>;
+    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;
+    getVesuAdapters(): VesuAdapter[];
+    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
+    getUnusedBalance(): Promise<SingleTokenInfo>;
+    maxNewDeposits(params?: {
+        isAPYComputation: boolean;
+    }): Promise<number>;
+    getMaxBorrowableAmount(params?: {
+        isAPYComputation: boolean;
+    }): Promise<{
+        netMaxBorrowableAmount: Web3Number;
+        maxBorrowables: {
+            amount: Web3Number;
+            dexSwappableAmount: Web3Number;
+            maxBorrowableAmount: Web3Number;
+            borrowableAsset: TokenInfo;
+            ltv: number;
+            poolId: ContractAddr;
+        }[];
+    }>;
+    getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number): Promise<Web3Number>;
+    getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean): Promise<{
+        amount: Web3Number;
+        dexSwappableAmount: Web3Number;
+        maxBorrowableAmount: Web3Number;
+        borrowableAsset: TokenInfo;
+    }>;
+    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;
+    }>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
 }
 declare const AUDIT_URL = "https://docs.troves.fi/p/security#starknet-vault-kit";
 declare function getFAQs(lstSymbol: string, underlyingSymbol: string, isLST: boolean): FAQ[];
@@ -2163,514 +2761,237 @@ declare const _riskFactor: RiskFactor[];
 declare function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string): string[];
 declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
 
-declare abstract class Operations {
-    abstract shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<Call[]>;
-    abstract shouldInvest(): Promise<{
-        shouldInvest: boolean;
-        vesuAmount: Web3Number;
-        extendedAmount: Web3Number;
-        extendedLeverage: number;
-        vesuLeverage: number;
-    }>;
-    abstract moveAssets(params: {
-        from: string;
-        to: string;
-        amount: Web3Number;
-    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<{
-        calls: Call[];
-        status: boolean;
-    }>;
-    abstract handleDeposit(): Promise<{
-        extendedAmountInBTC: Web3Number;
-        calls: Call[];
-    }>;
-    abstract handleWithdraw(amount: Web3Number): Promise<{
-        calls: Call[];
-        status: boolean;
-    }>;
-}
-
-interface VesuExtendedStrategySettings extends UniversalStrategySettings {
-    underlyingToken: TokenInfo;
-    borrowable_assets: TokenInfo[];
-    targetHealthFactor: number;
-    quoteAmountToFetchPrice: Web3Number;
-    minHealthFactor: number;
-    aumOracle: ContractAddr;
-    minimumWBTCDifferenceForAvnuSwap: number;
+interface BoostedxSTRKCarryStrategySettings extends UniversalStrategySettings {
+    depositToken: TokenInfo;
+    debtToken: TokenInfo;
+    lstHyperToken: TokenInfo;
+    vesuPoolId: ContractAddr;
+    maxLTV: number;
+    targetLTV: number;
+    hyperLstVaultAddress: ContractAddr;
+    hyperLstRedeemNFT: ContractAddr;
+    trovesStrategyId: string;
+    hasBtcFiRewards: boolean;
+    adapterIds?: {
+        vesu: string;
+        avnu: string;
+        hyper: string;
+        transfer: string;
+    };
 }
-declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySettings> extends SVKStrategy<S> implements Operations {
+declare class BoostedxSTRKCarryStrategy<S extends BoostedxSTRKCarryStrategySettings> extends SVKStrategy<S> {
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
     getTag(): string;
-    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<Call[]>;
-    shouldInvest(): Promise<{
-        shouldInvest: boolean;
-        vesuAmount: Web3Number;
-        extendedAmount: Web3Number;
-        extendedLeverage: number;
-        collateralPrice: number;
-        debtPrice: number;
-        vesuLeverage: number;
-    }>;
-    shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<Call[]>;
-    moveAssets(params: {
+    private getAdapterById;
+    private getTruePriceForToken;
+    getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number): Promise<Web3Number>;
+    getMinOutputAmountLSTSell(amountInLST: Web3Number): Promise<Web3Number>;
+    getVesuModifyPositionCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+        debtAmount?: Web3Number;
+    }): Promise<Call>;
+    getVesuPositions(): Promise<VaultPosition[]>;
+    getVesuHealthFactor(blockNumber?: BlockIdentifier): Promise<number>;
+    getModifyHyperPositionCall(params: {
+        isDeposit: boolean;
         amount: Web3Number;
-        from: string;
-        to: string;
-    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<{
-        calls: Call[];
-        status: boolean;
-    }>;
-    handleDeposit(): Promise<{
-        extendedAmountInBTC: Web3Number;
-        calls: Call[];
-    }>;
-    checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter): Promise<boolean>;
-    handleWithdraw(amount: Web3Number): Promise<{
-        calls: Call[];
-        status: boolean;
+    }): Promise<Call>;
+    getAvnuSwapCall(params: {
+        isDeposit: boolean;
+        amount: Web3Number;
+        minAmount?: Web3Number;
+    }): Promise<Call>;
+    /**
+     * Returns the deposit token balance sitting idle inside the vault contract itself.
+     * This balance can offset the required liquidity during withdrawal processing.
+     */
+    getUnusedBalanceVault(): Promise<Web3Number>;
+    /**
+     * Returns the current borrow token balance sitting unused in the vault allocator.
+     * This covers borrow token from prior borrow cycles that hasn't been swapped yet.
+     */
+    getUnusedDebt(): Promise<Web3Number>;
+    /**
+     * Returns the LST balance sitting in the vault allocator.
+     * This is non-zero when the previous cycle's request_redeem on the HyperPosition
+     * has been settled — the redeemed LST lands here and is ready to be swapped.
+     */
+    getLstInVaultAllocator(): Promise<Web3Number>;
+    /**
+     * Simulates depositing `depositAmount` on Vesu and returns the
+     * incremental borrow token that would be borrowed. Needed to size the AVNU swap
+     * call that is batched together with the Vesu call in the same transaction.
+     */
+    computeVesuDepositBorrowAmount(depositAmount: Web3Number): Promise<Web3Number>;
+    computeVesuWithdrawDebtDelta(withdrawAmount: Web3Number): Promise<Web3Number>;
+    getPendingHyperAssets(): Promise<Web3Number>;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
     }>;
+    getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]>;
     getAUM(): Promise<{
         net: SingleTokenInfo;
         prevAum: Web3Number;
         splits: PositionInfo[];
     }>;
+    /**
+     * Get Vesu APYs for collateral and debt positions
+     */
+    getVesuAPYs(): Promise<{
+        baseAPYs: number[];
+        rewardAPYs: number[];
+        positions: VaultPosition[];
+    }>;
+    /**
+     * Get APY from the Hyper LST vault position
+     */
+    getHyperVaultAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    /**
+     * Get APY for unused balance (idle funds in vault allocator)
+     */
+    protected getUnusedBalanceAPY(): Promise<{
+        apy: number;
+        weight: number;
+    }>;
+    /**
+     * Compute weighted APY from individual APYs, weights, and total AUM
+     */
+    private computeAPY;
+    /**
+     * Calculate net APY from base and reward APYs
+     */
+    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], totalWeightUSD: number): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    /**
+     * Calculate net APY across all positions (Vesu, Hyper vault, unused balance)
+     * weighted by USD value
+     */
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    /**
+     * Calculate future rewards (e.g. BTCFI rewards) contribution to AUM
+     * Similar to universal-strategy.tsx approach
+     */
+    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
+    getFundManagementCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call[] | null>;
 }
-declare const VesuExtendedTestStrategies: (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number) => IStrategyMetadata<VesuExtendedStrategySettings>[];
-
-declare const AddressesConfig: {
-    readonly tokens: {
-        readonly USDC: {
-            readonly address: "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
-            readonly decimals: 6;
-        };
-        readonly WBTC: {
-            readonly address: "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
-            readonly decimals: 8;
-        };
-    };
-    readonly contracts: {
-        readonly EXTENDED: "0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470";
-        readonly MULTIPLY: "0x07964760e90baa28841ec94714151e03fbc13321797e68a874e88f27c9d58513";
-    };
-    readonly wallet: {
-        readonly address: string;
-    };
-};
-declare const ExtendedConfig: {
-    readonly baseUrl: string;
-    readonly marketName: "BTC-USD";
-    readonly maintenanceMargin: 0.01;
-    readonly precision: 5;
-    readonly fees: number;
-    readonly minPositionSize: 0.0001;
-};
-declare const VesuConfig: {
-    readonly poolId: "0x02eef0c13b10b487ea5916b54c0a7f98ec43fb3048f60fdeedaf5b08f6f88aaf";
-    readonly maxLtv: 0.8428;
-    readonly maxLiquidationRatio: 0.86;
-    readonly targetHealthFactor: number;
-    readonly ekubo: {
-        readonly endpoint: "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}";
-        readonly priceMaxSlippage: number;
-    };
-    readonly avnu: {
-        readonly api: "https://starknet.api.avnu.fi/swap/v2/quotes";
-    };
-    readonly minDebtForVesuRebalacing: number;
-};
-declare const AbisConfig: {
-    readonly vesu: {
-        readonly multiply: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            items?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-        readonly pool: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-    };
-    readonly extended: {
-        readonly contract: ({
-            type: string;
-            name: string;
-            interface_name: string;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            members: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            variants: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            items: {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                }[];
-                outputs: {
-                    type: string;
-                }[];
-                state_mutability: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            inputs?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            inputs: {
-                name: string;
-                type: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            kind?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            members: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            variants?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        } | {
-            type: string;
-            name: string;
-            kind: string;
-            variants: {
-                name: string;
-                type: string;
-                kind: string;
-            }[];
-            interface_name?: undefined;
-            members?: undefined;
-            items?: undefined;
-            inputs?: undefined;
-        })[];
-    };
-};
+declare const BoostedxSTRKCarryStrategies: IStrategyMetadata<BoostedxSTRKCarryStrategySettings>[];
 
 /**
- * Function to return formatted amount to BigInt
- * Converts a decimal amount to the proper format for blockchain transactions
- * @param {number} amount - The decimal amount to convert
- * @param {number} fromTokenDecimals - The decimal precision of the token
- * @returns {string} The formatted amount as a hexadecimal string
+ * Filter option definition
+ */
+interface FilterOption {
+    id: string;
+    label: string;
+    icon?: string;
+}
+/**
+ * Strategy filter metadata - defines what filters are available
  */
-declare const returnFormattedAmount: (amount: number, toTokenDecimals: number) => string;
+interface StrategyFilterMetadata {
+    assets: FilterOption[];
+    protocols: FilterOption[];
+    quickFilters: FilterOption[];
+}
 /**
- * calculates the amount to distribute to Extend 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
+ * Strategy type enum
  */
-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 enum StrategyType {
+    EKUBO_CL = "ekubo",
+    UNIVERSAL = "universal",
+    HYPER_LST = "hyper-lst",
+    VESU_REBALANCE = "vesu-rebalance",
+    SENSEI = "sensei",
+    YOLO_VAULT = "yolo-vault",
+    BOOSTEDXSTRKCARRY = "boostedxstrkcarry"
+}
 /**
- * calculate the amount distribution for withdrawal
- * @param amount - The amount to withdraw
- * @param client - The client
- * @param marketName - The market name
- * @returns {object} Object containing avnu_amount and extended_amount
+ * Strategy metadata extracted from IStrategyMetadata
  */
-declare const calculateAmountDistributionForWithdrawal: (amountInUsdc: Web3Number, collateralPrice: number, collateralUnits: Web3Number, extendedPosition: Position[] | null) => Promise<{
-    vesu_amount: Web3Number;
-    extended_amount: Web3Number;
-    extended_leverage: number;
-    vesu_leverage: number;
-} | null>;
+interface StrategyMetadata {
+    id: string;
+    name: string;
+    type: StrategyType;
+    assets: string[];
+    protocols: string[];
+    tags: string[];
+    curator?: {
+        name: string;
+        logo: string;
+    };
+    isRetired: boolean;
+}
 /**
- * calculate the leverage required for Avnu
- * calculates the optimal leverage for Avnu based on LTV ratios and price drop protection
- * @returns {number} The calculated leverage value
+ * Strategy registry entry
  */
-declare const calculateVesuLeverage: () => number;
+interface StrategyRegistryEntry<T = any> {
+    metadata: IStrategyMetadata<T>;
+    type: StrategyType;
+}
 /**
- * calculate leverage for extended
- * calculates the maximum safe leverage for Extended based on maintenance margin and price drop protection
- * @returns {number} The calculated leverage value
+ * Build strategy registry from SDK strategies
  */
-declare const calculateExtendedLevergae: () => number;
+declare function buildStrategyRegistry(): StrategyRegistryEntry[];
 /**
- * calculates the debt amount for leverage operations
- * Determines how much debt to add or remove based on collateral changes and target health factor
- * @param {Web3Number} collateralAmount - Current collateral amount
- * @param {Web3Number} debtAmount - Current debt amount
- * @param {number} debtPrice - Current price of the debt token
- * @param {number} maxLtv - Maximum loan-to-value ratio (default: MAX_LTV_BTC_USDC)
- * @param {number} addedAmount - Amount being added to collateral
- * @param {number} collateralPrice - Current price of the collateral token
- * @param {boolean} isDeposit - Whether this is a deposit (true) or withdrawal (false)
- * @returns {object} Object containing deltadebtAmountUnits and isIncrease flag
+ * Get all strategy metadata from registry
  */
-declare const calculateDebtAmount: (collateralAmount: Web3Number, debtAmount: Web3Number, debtPrice: number, maxLtv: number | undefined, addedAmount: Web3Number, // this is in btc
-collateralPrice: number, isDeposit: boolean) => {
-    deltadebtAmountUnits: Web3Number;
-    isIncrease: boolean;
-} | {
-    deltadebtAmountUnits: null;
-    isIncrease: null;
-};
+declare function getAllStrategyMetadata(): StrategyMetadata[];
 /**
- * calculate the debt amount to be repaid for withdrawal
- * @param debtAmount in debt units
- * @param collateralAmount in collateral units
- * @param maxLtv in percentage
- * @param withdrawalAmount in collateral units
- * @param collateralPrice in usd
- * @param debtPrice in usd
- * @returns deltadebtAmountUnits in debt units
- *          isIncrease: true if the debt amount is increasing, false if it is decreasing
+ * Get filter metadata - defines available filters and their options
  */
-declare const calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number | undefined, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, usdcDecimals: number) => {
-    deltadebtAmountUnits: string;
-} | {
-    deltadebtAmountUnits: null;
-};
+declare function getFilterMetadata(): StrategyFilterMetadata;
 /**
- * calculate the amount to deposit on extended when incurring losses
- * @param client - The client
- * @returns The amount to deposit on extended when incurring losses
+ * Get live strategies (filter out retired)
  */
-declare const calculateAmountDepositOnExtendedWhenIncurringLosses: (client: ExtendedWrapper) => Promise<Web3Number | null>;
-declare const calculateExposureDelta: (exposure_extended: number, exposure_vesu: number) => number;
+declare function getLiveStrategies(): StrategyRegistryEntry[];
 /**
- * calculate the delta percentage between the current btc price and the last btc price
- * @param {number} btcPrice - The current btc price
- * @param {number} lastBtcPrice - The last btc price
- * @returns {number} The delta percentage
+ * Get strategies by type
  */
-declare const calculateBTCPriceDelta: (btcPrice: number, lastBtcPrice: number) => number;
-declare const calculateVesUPositionSizeGivenExtended: (extendedPositonValue: number, extendedHoldingAmount: Web3Number, collateralAmount: Web3Number, collateralPrice: number) => {
-    vesuAmountInUsd: string;
-    vesuAmountInBTC: Web3Number;
-    extendedAmountInBTC: Web3Number;
-};
+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",
+    YOLO_VAULT = "YOLO_VAULT",
+    BOOSTEDXSTRKCARRY = "BOOSTEDXSTRKCARRY"
+}
+declare function createUniversalStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>): UniversalStrategy<UniversalStrategySettings>;
+declare function createEkuboCLStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>): EkuboCLVault;
+declare function createYoloVaultStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<YoloVaultSettings>): YoLoVault;
+declare function createHyperLSTStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>): UniversalLstMultiplierStrategy<HyperLSTStrategySettings>;
+declare function createVesuRebalanceStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>): VesuRebalance;
+declare function createSenseiStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>): SenseiVault;
+declare function createBoostedXSTRKCarryStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<BoostedxSTRKCarryStrategySettings>): BoostedxSTRKCarryStrategy<BoostedxSTRKCarryStrategySettings>;
+/**
+ * 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 | YoLoVault | UniversalStrategy<UniversalStrategySettings> | UniversalLstMultiplierStrategy<HyperLSTStrategySettings> | BoostedxSTRKCarryStrategy<BoostedxSTRKCarryStrategySettings>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -2698,14 +3019,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>;
@@ -2736,6 +3066,7 @@ declare class Global {
     static getTokens(): Promise<TokenInfo[]>;
     static assert(condition: any, message: string): void;
     static getTokenInfoFromAddr(addr: ContractAddr): Promise<TokenInfo>;
+    static getTokenInfoFromName(tokenName: string): Promise<TokenInfo>;
     static setGlobalCache(key: string, data: any, ttl?: number): void;
     static getGlobalCache<T>(key: string): T | null;
 }
@@ -2867,6 +3198,16 @@ declare class Midas {
     } | number>;
 }
 
+declare class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS: string;
+    readonly contract: Contract;
+    private readonly USDC_ADDRESS;
+    private readonly USDC_DECIMALS;
+    constructor(config: IConfig, tokens: TokenInfo[]);
+    private div2Power128;
+    getPrice(tokenAddr: string, blockIdentifier?: BlockIdentifier): Promise<PriceInfo>;
+}
+
 declare class TelegramNotif {
     private subscribers;
     readonly bot: TelegramBot;
@@ -2903,7 +3244,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>;
@@ -2930,6 +3271,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;
@@ -2937,6 +3279,7 @@ declare const Deployer: {
     prepareMultiDeployContracts: typeof prepareMultiDeployContracts;
     executeDeployCalls: typeof executeDeployCalls;
     executeTransactions: typeof executeTransactions;
+    myWaitForTransaction: typeof myWaitForTransaction;
 };
 
 /**
@@ -3017,4 +3360,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, type AvnuSwapCallParams, AvnuWrapper, type Balance, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, type CancelOrderRequest, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, 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, 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, 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, calculateExposureDelta, calculateExtendedLevergae, calculateVesUPositionSizeGivenExtended, calculateVesuLeverage, 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, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuDepositParams, type AvnuSwapCallParams, type AvnuWithdrawParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, BoostedxSTRKCarryStrategies, BoostedxSTRKCarryStrategy, type BoostedxSTRKCarryStrategySettings, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, DEFAULT_TROVES_STRATEGIES_API, type DecreaseLeverParams, Deployer, type DepositParams, type DualActionAmount, type DualTokenInfo, ERC20, EXTENDED_CONTRACT, EXTENDED_SANITIZER, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, EkuboPricer, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FactoryStrategyType, FatalError, type FeeBps, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HealthFactorMath, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type ICurator, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type InputModeFromAction, InstantWithdrawalVault, LSTAPRService, LSTPriceType, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type LoggerConfig, type LoggerLevel, type ManageCall, MarginType, Midas, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, PRICE_ROUTER, type ParsedStarknetCall, PasswordJsonCryptoUtil, type PositionAPY, type PositionAmount, type PositionInfo, PositionTypeAvnuExtended, Pragma, type PriceInfo, type PriceMethod, Pricer, PricerAvnuApi, PricerBase, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SVK_SIMPLE_SANITIZER, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, StarknetCallParser, type StarknetCallParserOptions, Store, type StoreConfig, type StrategyAlert, type StrategyApyHistoryUIConfig, type StrategyCapabilities, type StrategyFilterMetadata, type StrategyInputMode, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, SvkTrovesAdapter, type SvkTrovesAdapterConfig, type Swap, type SwapInfo, type SwapPriceInfo, TRANSFER_SANITIZER, TelegramGroupNotif, TelegramNotif, type TokenAmount, TokenIndexingType, type TokenInfo, TokenMarketData, TokenTransferAdapter, type TokenTransferAdapterConfig, UNIVERSAL_ADAPTER_IDS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, UnwrapLabsCurator, type UserPositionCard, type UserPositionCardSubValueColor, type UserPositionCardsInput, type UserYoloInfo, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VaultType, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuDepositParams, type VesuModifyDelegationCallParams, VesuModifyPositionAdapter, type VesuModifyPositionAdapterConfig, type VesuModifyPositionCallParams, type VesuModifyPositionDepositParams, type VesuModifyPositionWithdrawParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, VesuPoolMetadata, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, type VesuWithdrawParams, Web3Number, type WithdrawParams, YoLoVault, type YoloSettings, type YoloSpendingLevel, type YoloVaultSettings, type YoloVaultStatus, YoloVaultStrategies, ZkLend, _riskFactor, assert, buildStrategyRegistry, configureLogger, createBoostedXSTRKCarryStrategy, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, createYoloVaultStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getAllStrategyTags, getContractDetails, getDefaultStoreConfig, getFAQs, getFilterMetadata, getInvestmentSteps, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTagDesciption, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };