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

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Contract, Call, Account, CairoCustomEnum, Uint256, RawArgs } from 'starknet';
+import { RpcProvider, BlockIdentifier, Contract, Uint256, Call, Account, CairoCustomEnum, RawArgs } from 'starknet';
 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 {
@@ -51,7 +51,33 @@ declare class ContractAddr {
     static eqString(a: string, b: string): boolean;
     toString(): string;
     toBigInt(): bigint;
-    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 {
@@ -97,6 +123,50 @@ interface IProtocol {
     name: string;
     logo: string;
 }
+declare enum StrategyCategory {
+    ALL = "all",
+    BTC = "btc",
+    META_VAULTS = "meta-vaults"
+}
+declare enum AuditStatus {
+    AUDITED = "Audited",
+    NOT_AUDITED = "Not Audited"
+}
+declare enum SourceCodeType {
+    OPEN_SOURCE = "Open Source",
+    CLOSED_SOURCE = "Closed Source"
+}
+declare enum AccessControlType {
+    MULTISIG_ACCOUNT = "Multisig Account",
+    STANDARD_ACCOUNT = "Standard Account"
+}
+declare enum InstantWithdrawalVault {
+    YES = "Yes",
+    NO = "No"
+}
+interface SourceCodeInfo {
+    type: SourceCodeType;
+    contractLink: string;
+}
+interface AccessControlInfo {
+    type: AccessControlType;
+    addresses: ContractAddr[];
+    timeLock: string;
+}
+interface SecurityMetadata {
+    auditStatus: AuditStatus;
+    sourceCode: SourceCodeInfo;
+    accessControl: AccessControlInfo;
+}
+interface RedemptionExpectedTime {
+    upto1M: string;
+    upto10M: string;
+    above10M: string;
+}
+interface RedemptionInfo {
+    instantWithdrawalVault: InstantWithdrawalVault;
+    expectedRedemptionTime?: RedemptionExpectedTime;
+}
 declare enum FlowChartColors {
     Green = "purple",
     Blue = "#35484f",
@@ -106,11 +176,63 @@ interface FAQ {
     question: string | React.ReactNode;
     answer: string | React.ReactNode;
 }
+/**
+ * Strategy Live Status - indicates the current state of a strategy
+ */
+declare enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    RETIRED = "Retired",
+    HOT = "Hot & New \uD83D\uDD25"
+}
+/**
+ * Strategy Tags - used for filtering and categorization
+ */
+declare enum StrategyTag {
+    EKUBO = "Ekubo",
+    EVERGREEN = "Evergreen",
+    HYPER_LST = "Hyper-LST",
+    VESU = "Vesu",
+    SENSEI = "Sensei",
+    ENDUR = "Endur",
+    BTC = "BTC"
+}
+/**
+ * Strategy Alert - informational or warning messages for users
+ */
+interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+/**
+ * Strategy Settings - configuration and UI settings for strategies
+ */
+interface StrategySettings {
+    maxTVL?: Web3Number;
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
+}
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
+ * @property security - Security-related metadata including audit status, source code information, and access control details.
+ * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 interface IStrategyMetadata<T> {
+    id: string;
     name: string;
     description: string | React.ReactNode;
     address: ContractAddr;
@@ -119,7 +241,6 @@ interface IStrategyMetadata<T> {
     depositTokens: TokenInfo[];
     protocols: IProtocol[];
     auditUrl?: string;
-    maxTVL: Web3Number;
     risk: {
         riskFactor: RiskFactor[];
         netRisk: number;
@@ -145,6 +266,30 @@ interface IStrategyMetadata<T> {
         logo: string;
     };
     isPreview?: boolean;
+    category?: StrategyCategory;
+    tags?: StrategyTag[];
+    security?: SecurityMetadata;
+    redemptionInfo?: RedemptionInfo;
+    settings?: StrategySettings;
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: {
+                name: string;
+                logo: string;
+            };
+            pool?: {
+                name: string;
+                logos?: string[];
+            };
+            apr?: number;
+            borrow?: {
+                apr?: number;
+            };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -170,16 +315,32 @@ interface VaultPosition {
     usdValue: number;
     token: TokenInfo;
     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;
     ENDUR: IProtocol;
     EXTENDED: IProtocol;
-    EKUBO: IProtocol;
-    AVNU: IProtocol;
-    VAULT: IProtocol;
 };
 
 interface ILendingMetadata {
@@ -258,7 +419,7 @@ declare class Pricer extends PricerBase {
     start(): void;
     isStale(timestamp: Date, tokenName: string): boolean;
     assertNotStale(timestamp: Date, tokenName: string): void;
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
+    getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo>;
     protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
     _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
@@ -270,7 +431,140 @@ 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>;
+}
+
+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>;
+    /**
+     * @description Get the health factor of the user for given lending and debt tokens
+     * @param lending_tokens
+     * @param debt_tokens
+     * @param user
+     * @returns hf (e.g. returns 1.5 for 150% health factor)
+     */
+    get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number>;
+    /**
+     * @description Get the health factor of the user
+     * - Considers all tokens for collateral and debt
+     */
+    get_health_factor(user: ContractAddr): Promise<number>;
+    getPositionsSummary(user: ContractAddr): Promise<{
+        collateralUSD: number;
+        debtUSD: number;
+    }>;
+    /**
+     * @description Get the token-wise collateral and debt positions of the user
+     * @param user Contract address of the user
+     * @returns Promise<ILendingPosition[]>
+     */
+    getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
+}
+
+declare class PricerFromApi extends PricerBase {
+    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;
+    }>;
+    /**
+     * 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
+     */
+    getHistoricalPrice(tokenSymbol: string, blockNumber: BlockIdentifier): Promise<PriceInfo>;
+}
+
+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>;
+}
+
+interface Route {
+    token_from: string;
+    token_to: string;
+    exchange_address: string;
+    percent: number;
+    additional_swap_params: string[];
+}
+interface SwapInfo {
+    token_from_address: string;
+    token_from_amount: Uint256;
+    token_to_address: string;
+    token_to_amount: Uint256;
+    token_to_min_amount: Uint256;
+    beneficiary: string;
+    integrator_fee_amount_bps: number;
+    integrator_fee_recipient: string;
+    routes: Route[];
+}
+declare class AvnuWrapper {
+    getQuotes(fromToken: string, toToken: string, amountWei: string, taker: string, retry?: number, excludeSources?: string[]): Promise<Quote>;
+    getSwapInfo(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string, integratorFeeBps: number, integratorFeeRecipient: string, minAmount?: string, options?: AvnuOptions): Promise<SwapInfo>;
+    static buildZeroSwap(tokenToSell: ContractAddr, beneficiary: string, tokenToBuy?: ContractAddr): SwapInfo;
+}
+
+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;
+    }>;
+}
+
+interface HarvestInfo {
+    rewardsContract: ContractAddr;
+    token: ContractAddr;
+    startDate: Date;
+    endDate: Date;
+    claim: {
+        id: number;
+        amount: Web3Number;
+        claimee: ContractAddr;
+    };
+    actualReward: Web3Number;
+    proof: string[];
 }
 
 interface CacheData$1 {
@@ -285,275 +579,291 @@ declare class CacheClass {
     isCacheValid(key: string): boolean;
 }
 
-interface LeveledLogMethod {
-    (message: string, ...meta: any[]): void;
-    (message: any): void;
+interface SingleActionAmount {
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
 }
-interface MyLogger {
-    error: LeveledLogMethod;
-    warn: LeveledLogMethod;
-    info: LeveledLogMethod;
-    verbose: LeveledLogMethod;
-    debug: LeveledLogMethod;
+interface SingleTokenInfo extends SingleActionAmount {
+    usdValue: number;
 }
-declare const logger: MyLogger;
-
-interface LeafData {
-    id: bigint;
-    readableId: string;
-    data: bigint[];
+interface DualActionAmount {
+    token0: SingleActionAmount;
+    token1: SingleActionAmount;
 }
-interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
-    format: 'standard-v1';
-    leafEncoding: ValueType[];
+interface DualTokenInfo {
+    usdValue: number;
+    token0: SingleTokenInfo;
+    token1: SingleTokenInfo;
 }
-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 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, blockIdentifier?: BlockIdentifier): Promise<TVLInfo>;
+    getTVL(): Promise<TVLInfo>;
+    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
 }
 
-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 PoolProps {
+    pool_id: ContractAddr;
+    max_weight: number;
+    v_token: ContractAddr;
 }
-interface DepositParams {
-    amount: Web3Number;
+interface Change {
+    pool_id: ContractAddr;
+    changeAmt: Web3Number;
+    finalAmt: Web3Number;
+    isDeposit: boolean;
 }
-interface WithdrawParams {
-    amount: Web3Number;
+interface VesuRebalanceSettings {
+    feeBps: number;
 }
-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 = {
+interface PoolInfoFull {
+    pool_id: ContractAddr;
+    pool_name: string | undefined;
+    max_weight: number;
+    current_weight: number;
+    v_token: ContractAddr;
     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);
+    usdValue: Web3Number;
+    APY: {
+        baseApy: number;
+        defiSpringApy: number;
+        netApy: number;
+    };
+    currentUtilization: number;
+    maxUtilization: number;
+}
+/**
+ * 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;
     /**
-     * Loop through all supported positions and return amount, usd value, remarks and apy for each
+     * 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
      */
-    getPositions(): Promise<PositionInfo[]>;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>);
     /**
-     * Implemented by child adapters to compute APY for a given supported position
+     * 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
      */
-    protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<starknet.Call[]>;
     /**
-     * Implemented by child adapters to fetch amount for a given supported position
+     * 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
      */
-    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<starknet.Call[]>;
     /**
-     * Implemented by child adapters to calculate maximum deposit positions
-     * @param amount Optional amount in baseToken to deposit
+     * Returns the underlying asset token of the strategy.
+     * @returns The deposit token supported by this strategy
      */
-    abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    asset(): TokenInfo;
     /**
-     * Implemented by child adapters to calculate maximum withdraw positions
+     * Returns the number of decimals used by the strategy token.
+     * @returns Number of decimals (same as the underlying token)
      */
-    abstract maxWithdraw(): Promise<PositionInfo>;
+    decimals(): number;
     /**
-     * Uses pricer to convert an amount of an asset to USD value
+     * Calculates the Total Value Locked (TVL) for a specific user.
+     * @param user - Address of the user
+     * @param blockIdentifier - Block identifier for the query
+     * @returns Object containing the amount in token units and USD value
      */
-    protected getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number>;
-    protected constructSimpleLeafData(params: {
-        id: string;
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-    }, sanitizer?: ContractAddr): LeafData;
+    getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
     /**
-     * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+     * Calculates user realized APY based on trueSharesBasedAPY method.
+     * Returns the APY as a number.
      */
-    protected abstract _getDepositLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
     /**
-     * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
      */
-    protected abstract _getWithdrawLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
+    getTVL(): Promise<SingleTokenInfo>;
+    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;
+    }>;
     /**
-     * Returns deposit leaf adapter using configured proof id
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
      */
-    getDepositLeaf(): AdapterLeafType<DepositParams>;
+    netAPY(): Promise<number>;
     /**
-     * Returns withdraw leaf adapter using configured proof id
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
      */
-    getWithdrawLeaf(): AdapterLeafType<WithdrawParams>;
+    netAPYGivenPools(pools: PoolInfoFull[]): Promise<number>;
     /**
-     * Implementor must provide deposit call
-     * @param params
+     * 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
      */
-    abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    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[]>;
     /**
-     * Implementor must provide withdraw call
-     * @param params
+     * 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
      */
-    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>;
+    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
+        vToken: ContractAddr;
+        fee: Web3Number;
+    }>>;
 }
+/**
+ * Represents the Vesu Rebalance Strategies.
+ */
+declare const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[];
 
-interface FlashloanCallParams {
-    amount: Web3Number;
-    data: bigint[];
+interface EkuboPoolKey {
+    token0: ContractAddr;
+    token1: ContractAddr;
+    fee: string;
+    tick_spacing: string;
+    extension: string;
 }
-interface ApproveCallParams {
+interface EkuboBounds {
+    lowerTick: bigint;
+    upperTick: bigint;
+}
+interface FeeHistory {
+    date: string;
+    tokenInfo: TokenInfo;
     amount: Web3Number;
 }
-interface AvnuSwapCallParams {
-    props: SwapInfo;
-}
-interface CommonAdapterConfig {
-    id: string;
-    vaultAddress: ContractAddr;
-    vaultAllocator: ContractAddr;
-    manager: ContractAddr;
-    asset: ContractAddr;
-}
-declare class CommonAdapter {
-    config: CommonAdapterConfig;
-    constructor(config: CommonAdapterConfig);
-    protected constructSimpleLeafData(params: {
-        id: string;
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-    }, sanitizer?: ContractAddr): LeafData;
-    getFlashloanAdapter(): Promise<AdapterLeafType<FlashloanCallParams>>;
-    getFlashloanCall(params: FlashloanCallParams): Promise<ManageCall[]>;
-    getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams>;
-    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
-    getApproveCall(token: ContractAddr, spender: ContractAddr): (params: ApproveCallParams) => Promise<{
-        sanitizer: ContractAddr;
-        call: {
-            contractAddress: ContractAddr;
-            selector: string;
-            calldata: bigint[];
-        };
-    }[]>;
-    getBringLiquidityCall(): GenerateCallFn<ApproveCallParams>;
-}
-
-interface HarvestInfo {
-    rewardsContract: ContractAddr;
-    token: ContractAddr;
-    startDate: Date;
-    endDate: Date;
-    claim: {
-        id: number;
-        amount: Web3Number;
-        claimee: ContractAddr;
-    };
-    actualReward: Web3Number;
-    proof: string[];
-}
-
-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;
+/**
+ * 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 */
@@ -571,11 +881,11 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
     poolKey: EkuboPoolKey | undefined;
     readonly avnu: AvnuWrapper;
     /**
-     * Creates a new VesuRebalance strategy instance.
+     * Creates a new EkuboCLVault 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
+     * @throws {Error} If more than two deposit tokens are specified
      */
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>);
     matchInputAmounts(amountInfo: DualActionAmount): Promise<DualActionAmount>;
@@ -587,17 +897,23 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
     rebalanceCall(newBounds: EkuboBounds, swapParams: SwapInfo): Call[];
     handleUnusedCall(swapParams: SwapInfo): Call[];
     handleFeesCall(): Call[];
-    getFeeHistory(timePeriod?: '24h' | '7d' | '30d' | '3m'): Promise<{
+    getFeeHistory(timePeriod?: "24h" | "7d" | "30d" | "3m"): Promise<{
         summary: DualTokenInfo;
         history: FeeHistory[];
     }>;
     netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
-    feeBasedAPY(timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
+    /**
+     * Calculates realized APY based on TVL per share growth, always valued in USDC.
+     * This is a vault-level metric (same for all users) and works for all strategies,
+     * regardless of quote asset configuration.
+     */
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    feeBasedAPY(timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number>;
     /**
      * Calculates assets before and now in a given token of TVL per share to observe growth
      * @returns {Promise<number>} The weighted average APY across all pools
      */
-    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<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>;
@@ -705,7 +1021,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,6 +1071,190 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
  */
 declare const EkuboCLVaultStrategies: IStrategyMetadata<CLVaultStrategySettings>[];
 
+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, blockIdentifier?: BlockIdentifier): Promise<SingleTokenInfo>;
+    getTVL(): Promise<SingleTokenInfo>;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
+    getPositionInfo(): Promise<{
+        collateralXSTRK: Web3Number;
+        collateralUSDValue: Web3Number;
+        debtSTRK: Web3Number;
+        debtUSDValue: Web3Number;
+        xSTRKPrice: number;
+        collateralInSTRK: number;
+    }>;
+    getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
+    getSettings: () => Promise<starknet.CallResult>;
+}
+declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
+
+interface LeveledLogMethod {
+    (message: string, ...meta: any[]): void;
+    (message: any): void;
+}
+interface MyLogger {
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    info: LeveledLogMethod;
+    verbose: LeveledLogMethod;
+    debug: LeveledLogMethod;
+}
+declare const logger: MyLogger;
+
+interface LeafData {
+    id: bigint;
+    readableId: string;
+    data: bigint[];
+}
+interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+    format: 'standard-v1';
+    leafEncoding: ValueType[];
+}
+declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
+    protected readonly tree: HexString[];
+    protected readonly values: StandardMerkleTreeData<LeafData>['values'];
+    protected readonly leafEncoding: ValueType[];
+    protected constructor(tree: HexString[], values: StandardMerkleTreeData<LeafData>['values'], leafEncoding: ValueType[]);
+    static of(values: LeafData[], leafEncoding?: ValueType[], options?: MerkleTreeOptions): StandardMerkleTree;
+    static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean;
+    static verifyMultiProof<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], multiproof: MultiProof<BytesLike, T>): boolean;
+    dump(): StandardMerkleTreeData<LeafData>;
+}
+
+/**
+ * Convert SDK TVL info (SingleTokenInfo or DualTokenInfo) to client AmountsInfo format
+ */
+declare function toAmountsInfo(tvlInfo: SingleTokenInfo | DualTokenInfo): Omit<AmountsInfo, "amounts"> & {
+    amounts: Array<{
+        amount: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+};
+/**
+ * Detect what capabilities a strategy instance has
+ */
+declare function detectCapabilities(strategy: BaseStrategy<any, any>): StrategyCapabilities;
+/**
+ * Check if a strategy is a dual-token strategy
+ */
+declare function isDualTokenStrategy(strategy: BaseStrategy<any, any>): boolean;
+
+type 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[];
+    };
+}
+type GenerateCallFn<T> = (params: T) => ManageCall;
+type AdapterLeafType<T> = {
+    leaf: 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 = {
+    amount: Web3Number;
+    usdValue: number;
+    remarks?: string;
+    apy: PositionAPY;
+};
+declare abstract class BaseAdapter extends CacheClass {
+    constructor();
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
+}
+
+interface FlashloanCallParams {
+    amount: Web3Number;
+    data: bigint[];
+}
+interface ApproveCallParams {
+    amount: Web3Number;
+}
+interface AvnuSwapCallParams {
+    props: SwapInfo;
+}
+interface CommonAdapterConfig {
+    id: string;
+    vaultAddress: ContractAddr;
+    vaultAllocator: ContractAddr;
+    manager: ContractAddr;
+    asset: ContractAddr;
+}
+declare class CommonAdapter extends BaseAdapter {
+    config: CommonAdapterConfig;
+    constructor(config: CommonAdapterConfig);
+    getFlashloanAdapter(): AdapterLeafType<FlashloanCallParams>;
+    getFlashloanCall(params: FlashloanCallParams): ManageCall;
+    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveCall(token: ContractAddr, spender: ContractAddr): (params: ApproveCallParams) => {
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    };
+    getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams>;
+    getBringLiquidityCall(): (params: ApproveCallParams) => {
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    };
+    getAvnuAdapter(fromToken: ContractAddr, toToken: ContractAddr, id: string, isMiddleware: boolean): () => AdapterLeafType<AvnuSwapCallParams>;
+    getAvnuCall(fromToken: ContractAddr, toToken: ContractAddr, isMiddleware: boolean): GenerateCallFn<AvnuSwapCallParams>;
+}
+
 interface VesuPoolsInfo {
     pools: any[];
     isErrorPoolsAPI: boolean;
@@ -851,7 +1352,6 @@ declare const VesuPools: {
     Genesis: ContractAddr;
     Re7xSTRK: ContractAddr;
     Re7xBTC: ContractAddr;
-    Re7USDCPrime: ContractAddr;
 };
 declare const extensionMap: {
     [key: string]: ContractAddr;
@@ -860,14 +1360,44 @@ declare function getVesuSingletonAddress(vesuPool: ContractAddr): {
     addr: ContractAddr;
     isV2: boolean;
 };
-declare class VesuAdapter extends CacheClass {
+declare class VesuAdapter extends BaseAdapter {
     VESU_MULTIPLY_V1: ContractAddr;
     VESU_MULTIPLY: ContractAddr;
     config: VesuAdapterConfig;
     networkConfig: IConfig | undefined;
     pricer: PricerBase | undefined;
     constructor(config: VesuAdapterConfig);
+    getModifyPosition: () => AdapterLeafType<VesuModifyPositionCallParams>;
+    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;
+            };
+        };
+    };
+    getModifyPositionCall: (params: VesuModifyPositionCallParams) => ManageCall;
+    getMultiplyAdapter: (id: string) => LeafAdapterFn<VesuMultiplyCallParams>;
+    getMultiplyCall: (params: VesuMultiplyCallParams) => ManageCall;
+    getVesuModifyDelegationAdapter: (id: string) => LeafAdapterFn<VesuModifyDelegationCallParams>;
     getVesuModifyDelegationCall: (params: VesuModifyDelegationCallParams) => ManageCall;
+    getDefispringRewardsAdapter: (id: string) => () => AdapterLeafType<VesuDefiSpringRewardsCallParams>;
+    getDefiSpringClaimCall: () => GenerateCallFn<VesuDefiSpringRewardsCallParams>;
     formatAmountTypeEnum(amountType: VesuAmountType): CairoCustomEnum;
     formatAmountDenominationEnum(denomination: VesuAmountDenomination): CairoCustomEnum;
     getVesuSingletonContract(config: IConfig, poolId: ContractAddr): {
@@ -906,1112 +1436,15 @@ declare class VesuAdapter extends CacheClass {
     getMaxUtilizationGivenRatePerSecond(interestRateConfig: InterestRateConfig, ratePerSecond: bigint, timeDelta: bigint, last_full_utilization_rate: bigint): bigint;
 }
 
-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 VesuMultiplyAdapterConfig extends BaseAdapterConfig {
-    poolId: ContractAddr;
-    collateral: TokenInfo;
-    debt: TokenInfo;
-    targetHealthFactor: number;
-    minHealthFactor: number;
-    quoteAmountToFetchPrice: Web3Number;
-    minimumVesuMovementAmount: number;
-}
-declare class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: VesuMultiplyAdapterConfig;
-    readonly vesuAdapter: VesuAdapter;
-    readonly tokenMarketData: TokenMarketData;
-    readonly minimumVesuMovementAmount: number;
-    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>;
-}
-
-/**
- * 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 UpdateLeverageRequest {
-    leverage: string;
-    market: string;
-}
-interface FundingRate {
-    m: string;
-    f: string;
-    t: number;
-}
-
-/**
- * ExtendedWrapper - TypeScript wrapper for Extended Exchange API
- * Provides a clean interface to interact with the Extended Exchange trading API
- */
-
-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<{}>>;
-    /**
-     * Get all open orders
-     */
-    getOpenOrders(marketName?: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
-    /**
-     * Update leverage on the market
-     * @param request
-     * @returns
-     */
-    updateLeverage(request: UpdateLeverageRequest): Promise<ExtendedApiResponse<{}>>;
-    /**
-     * Get asset operations with optional filtering
-     */
-    getAssetOperations(options?: {
-        id?: number;
-        operationsType?: AssetOperationType[];
-        operationsStatus?: AssetOperationStatus[];
-        startTime?: number;
-        endTime?: number;
-        cursor?: number;
-        limit?: number;
-    }): Promise<ExtendedApiResponse<AssetOperation[]>>;
-    /**
-     * Health check endpoint
-     */
-    healthCheck(): Promise<ExtendedApiResponse<MarketStats>>;
-    /**
-     * Convenience method to create a buy order
-     */
-    createBuyOrder(marketName: string, amount: string, price: string, options?: {
-        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>>;
-    /**
-     * Convenience method to create a sell order
-     */
-    createSellOrder(marketName: string, amount: string, price: string, options?: {
-        postOnly?: boolean;
-        previousOrderId?: number;
-        externalId?: string;
-        timeInForce?: TimeInForce;
-    }): Promise<ExtendedApiResponse<PlacedOrder>>;
-    /**
-     * Get positions for a specific market
-     */
-    getPositionsForMarket(marketName: string): Promise<ExtendedApiResponse<Position[]>>;
-    /**
-     * Get open orders for a specific market
-     */
-    getOpenOrdersForMarket(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
-    /**
-     * Cancel order by ID (convenience method)
-     */
-    cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>>;
-    /**
-     * Get order history for a specific market
-     * @param marketName - The name of the market to get order history for
-     * @returns The order history for the specified market
-     */
-    getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>>;
-    /**
-     * Withdraw USDC (convenience method)
-     */
-    withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number>>;
-    /**
-     * Get funding rates for a specific market
-     * @param marketName - The name of the market to get funding rates for
-     * @returns The funding rates for the specified market
-     */
-    getFundingRates(marketName: string, side: string): Promise<ExtendedApiResponse<FundingRate[]>>;
-}
-
-interface Route {
-    token_from: string;
-    token_to: string;
-    exchange_address: string;
-    percent: number;
-    additional_swap_params: string[];
-}
-interface SwapInfo {
-    token_from_address: string;
-    token_from_amount: Uint256;
-    token_to_address: string;
-    token_to_amount: Uint256;
-    token_to_min_amount: Uint256;
-    beneficiary: string;
-    integrator_fee_amount_bps: number;
-    integrator_fee_recipient: string;
-    routes: Route[];
-}
-declare class AvnuWrapper {
-    getQuotes(fromToken: string, toToken: string, amountWei: string, taker: string, retry?: number, excludeSources?: string[]): Promise<Quote>;
-    getSwapInfo(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string, integratorFeeBps: number, integratorFeeRecipient: string, minAmount?: string, options?: AvnuOptions): Promise<SwapInfo>;
-    static buildZeroSwap(tokenToSell: ContractAddr, beneficiary: string, tokenToBuy?: ContractAddr): SwapInfo;
-    getSwapCallData(quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>, taker: string): Promise<bigint[][]>;
-}
-
-interface AvnuAdapterConfig extends BaseAdapterConfig {
-    baseUrl: string;
-    avnuContract: ContractAddr;
-    slippage: number;
-}
-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;
-        id: string;
-    }[];
-    protected _getLegacySwapLeaf(): {
-        target: ContractAddr;
-        method: string;
-        packedArguments: bigint[];
-        sanitizer: ContractAddr;
-        id: string;
-    }[];
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-    getSwapCallData(quote: Quote): Promise<bigint[][]>;
-    getHealthFactor(): Promise<number>;
-    fetchQuoteWithRetry(params: Record<string, any>, retries?: number): Promise<any>;
-    getQuotesAvnu(from_token_address: string, to_token_address: string, amount: number, //amount in btc units
-    takerAddress: string, toTokenDecimals: number, usdcToBtc: boolean, maxIterations?: number, tolerance?: number): Promise<Quote | null>;
-    getPriceOfToken(tokenAddress: string, retries?: number): Promise<number | null>;
-}
-
-interface ExtendedAdapterConfig extends BaseAdapterConfig {
-    vaultIdExtended: number;
-    extendedContract: ContractAddr;
-    extendedBackendUrl: string;
-    extendedApiKey: string;
-    extendedTimeout: number;
-    extendedRetries: number;
-    extendedBaseUrl: string;
-    extendedMarketName: string;
-    extendedPrecision: number;
-    avnuAdapter: AvnuAdapter;
-    retryDelayForOrderStatus: number;
-    minimumExtendedMovementAmount: number;
-}
-declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: ExtendedAdapterConfig;
-    readonly client: ExtendedWrapper;
-    readonly retryDelayForOrderStatus: number;
-    readonly minimumExtendedMovementAmount: number;
-    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>;
-    };
-    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;
-    }>;
-    createOrder(leverage: string, btcAmount: number, side: OrderSide, attempt?: number, maxAttempts?: number): Promise<{
-        position_id: string;
-        btc_exposure: string;
-    } | null>;
-    createExtendedPositon(client: ExtendedWrapper, marketName: string, amount: string, price: string, side: OrderSide): Promise<{
-        position_id: string;
-    } | null>;
-    getDepositOrWithdrawalStatus(orderId: number | string, // for deposits, send txn hash as string
-    operationsType: AssetOperationType): Promise<boolean>;
-}
-
-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 {
-}
-declare class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-    readonly config: UnusedBalanceAdapterConfig;
-    readonly tokenMarketData: TokenMarketData;
-    constructor(config: UnusedBalanceAdapterConfig);
-    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;
-    }[];
-    getHealthFactor(): Promise<number>;
-    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
-    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
-}
-
-interface SingleActionAmount {
-    tokenInfo: TokenInfo;
-    amount: Web3Number;
-}
-interface SingleTokenInfo extends SingleActionAmount {
-    usdValue: number;
-}
-interface APYInfo {
-    net: number;
-    splits: {
-        apy: number;
-        id: string;
-    }[];
-}
-interface DualActionAmount {
-    token0: SingleActionAmount;
-    token1: SingleActionAmount;
-}
-interface DualTokenInfo {
-    usdValue: number;
-    token0: SingleTokenInfo;
-    token1: SingleTokenInfo;
-}
-interface CacheData {
-    timestamp: number;
-    ttl: number;
-    data: any;
-}
-declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
-    readonly config: IConfig;
-    readonly cache: Map<string, CacheData>;
-    constructor(config: IConfig);
-    getUserTVL(user: ContractAddr): Promise<TVLInfo>;
-    getTVL(): Promise<TVLInfo>;
-    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getUnusedBalance(): Promise<SingleTokenInfo>;
-    netAPY(): Promise<APYInfo>;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
-    }>;
-    getHealthFactors(): Promise<number[]>;
-}
-
-/**
- * TokenMarketData class that combines LST APR and Midas modules
- * to provide unified APY, price, and TVL functions for tokens
- */
-declare class TokenMarketData {
-    private pricer;
-    private config;
-    constructor(pricer: PricerBase, config: IConfig);
-    /**
-     * Get APY for a token
-     * - If it's an LST token, returns LST APY
-     * - If it's a Midas token, returns Midas APY
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get APY for
-     * @returns APY in absolute terms (not percentage)
-     */
-    getAPY(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get price for a token using the pricer module
-     * @param tokenInfo The token to get price for
-     * @returns Price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    getPrice(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get true price for a token
-     * - For LST tokens: Uses convert_to_assets to get true exchange rate
-     * - For Midas tokens: Uses Midas price API
-     * - For other tokens: Falls back to regular pricer
-     * @param tokenInfo The token to get true price for
-     * @returns True price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    getTruePrice(tokenInfo: TokenInfo): Promise<number>;
-    /**
-     * Get TVL for a token
-     * - If it's a Midas token, returns Midas TVL data
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get TVL for
-     * @returns TVL as SingleTokenInfo or 0
-     */
-    getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo>;
-    /**
-     * Check if a token is supported for APY data
-     * @param tokenInfo The token to check
-     * @returns True if the token has APY data available
-     */
-    isAPYSupported(tokenInfo: TokenInfo): boolean;
-    /**
-     * Check if a token is supported for TVL data
-     * @param tokenInfo The token to check
-     * @returns True if the token has TVL data available
-     */
-    isTVLSupported(tokenInfo: TokenInfo): boolean;
-}
-
-declare class Pragma {
-    contractAddr: string;
-    readonly contract: Contract;
-    constructor(provider: RpcProvider);
-    getPrice(tokenAddr: string): Promise<number>;
-}
-
-declare class ZkLend extends ILending implements ILending {
-    readonly pricer: Pricer;
-    static readonly POOLS_URL = "https://app.zklend.com/api/pools";
-    private POSITION_URL;
-    constructor(config: IConfig, pricer: Pricer);
-    init(): Promise<void>;
-    /**
-     * @description Get the health factor of the user for given lending and debt tokens
-     * @param lending_tokens
-     * @param debt_tokens
-     * @param user
-     * @returns hf (e.g. returns 1.5 for 150% health factor)
-     */
-    get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number>;
-    /**
-     * @description Get the health factor of the user
-     * - Considers all tokens for collateral and debt
-     */
-    get_health_factor(user: ContractAddr): Promise<number>;
-    getPositionsSummary(user: ContractAddr): Promise<{
-        collateralUSD: number;
-        debtUSD: number;
-    }>;
-    /**
-     * @description Get the token-wise collateral and debt positions of the user
-     * @param user Contract address of the user
-     * @returns Promise<ILendingPosition[]>
-     */
-    getPositions(user: ContractAddr): Promise<ILendingPosition[]>;
-}
-
-declare class PricerFromApi extends PricerBase {
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-    getPriceFromMyAPI(tokenSymbol: string): Promise<{
-        price: number;
-        timestamp: Date;
-    }>;
-}
-
-declare class ERC20 {
-    readonly config: IConfig;
-    constructor(config: IConfig);
-    contract(addr: string | ContractAddr): Contract;
-    balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
-    allowance(token: string | ContractAddr, owner: string | ContractAddr, spender: string | ContractAddr, tokenDecimals: number): Promise<Web3Number>;
-    transfer(token: string | ContractAddr, to: string | ContractAddr, amount: Web3Number): starknet.Call;
-    approve(token: string | ContractAddr, spender: string | ContractAddr, amount: Web3Number): starknet.Call;
-}
-
-declare class AutoCompounderSTRK {
-    readonly config: IConfig;
-    readonly addr: ContractAddr;
-    readonly pricer: Pricer;
-    private initialized;
-    contract: Contract | null;
-    readonly metadata: {
-        decimals: number;
-        underlying: {
-            address: ContractAddr;
-            name: string;
-            symbol: string;
-        };
-        name: string;
-    };
-    constructor(config: IConfig, pricer: Pricer);
-    init(): Promise<void>;
-    waitForInitilisation(): Promise<void>;
-    /** Returns shares of user */
-    balanceOf(user: ContractAddr): Promise<Web3Number>;
-    /** Returns underlying assets of user */
-    balanceOfUnderlying(user: ContractAddr): Promise<Web3Number>;
-    /** Returns usd value of assets */
-    usdBalanceOfUnderlying(user: ContractAddr): Promise<{
-        usd: Web3Number;
-        assets: Web3Number;
-    }>;
-}
-
-interface PoolProps {
-    pool_id: ContractAddr;
-    max_weight: number;
-    v_token: ContractAddr;
-}
-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;
-}
-/**
- * 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>;
-    /**
-     * 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[]>;
-    harvest(acc: Account, endpoint?: string): Promise<starknet.Call[]>;
-    /**
-     * Calculates the fees deducted in different vTokens based on the current and previous state.
-     * @param previousTotalSupply - The total supply of the strategy token before the transaction
-     * @returns {Promise<Array<{ vToken: ContractAddr, fee: Web3Number }>>} Array of fees deducted in different vTokens
-     */
-    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
-        vToken: ContractAddr;
-        fee: Web3Number;
-    }>>;
-}
-/**
- * Represents the Vesu Rebalance Strategies.
- */
-declare const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[];
-
-interface SenseiVaultSettings {
-    mainToken: TokenInfo;
-    secondaryToken: TokenInfo;
-    targetHfBps: number;
-    feeBps: number;
-}
-declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
-    readonly address: ContractAddr;
-    readonly metadata: IStrategyMetadata<SenseiVaultSettings>;
-    readonly pricer: PricerBase;
-    readonly contract: Contract;
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>);
-    getUserTVL(user: ContractAddr): Promise<SingleTokenInfo>;
-    getTVL(): Promise<SingleTokenInfo>;
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    getPositionInfo(): Promise<{
-        collateralXSTRK: Web3Number;
-        collateralUSDValue: Web3Number;
-        debtSTRK: Web3Number;
-        debtUSDValue: Web3Number;
-        xSTRKPrice: number;
-        collateralInSTRK: number;
-    }>;
-    getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
-    getSettings: () => Promise<starknet.CallResult>;
-}
-declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
+declare const SIMPLE_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 VESU_SINGLETON: ContractAddr;
+declare function toBigInt(value: string | number): bigint;
 
 interface UniversalManageCall {
     proofs: string[];
@@ -2023,40 +1456,20 @@ interface UniversalStrategySettings {
     manager: ContractAddr;
     vaultAllocator: ContractAddr;
     redeemRequestNFT: ContractAddr;
+    aumOracle: ContractAddr;
     leafAdapters: LeafAdapterFn<any>[];
-    adapters: {
-        id: string;
-        adapter: BaseAdapter<DepositParams, WithdrawParams>;
-    }[];
-}
-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"
+    adapters: {
+        id: string;
+        adapter: BaseAdapter;
+    }[];
+    targetHealthFactor: number;
+    minHealthFactor: number;
 }
-declare function getContractDetails(settings: UniversalStrategySettings & {
-    aumOracle?: ContractAddr;
-}): {
-    address: ContractAddr;
-    name: string;
-}[];
-
-/**
- * Base class for all SVK (Starknet Vault Kit) strategies.
- * Contains common functions that are shared across all SVK strategies.
- */
-declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+declare enum AUMTypes {
+    FINALISED = "finalised",
+    DEFISPRING = "defispring"
+}
+declare class UniversalStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
     /** Contract address of the strategy */
     readonly address: ContractAddr;
     /** Pricer instance for token price calculations */
@@ -2065,63 +1478,50 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
     readonly metadata: IStrategyMetadata<S>;
     /** Contract instance for interacting with the strategy */
     readonly contract: Contract;
-    /** Manager contract instance for merkle verification */
     readonly managerContract: Contract;
-    /** Cached merkle tree instance */
     merkleTree: StandardMerkleTree | undefined;
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
     /**
-     * Returns the asset token for this strategy
+     * Returns the underlying asset token of the strategy.
+     * @returns The deposit token supported by this strategy
      */
     asset(): TokenInfo;
-    /**
-     * Returns the unused balance in the vault allocator.
-     * Note: This function is common for any SVK strategy.
-     */
-    getUnusedBalance(): Promise<SingleTokenInfo>;
-    /**
-     * Bridges liquidity from the vault allocator back to the vault.
-     * Note: This function is common for any SVK strategy.
-     */
-    getBringLiquidityCall(params: {
-        amount: Web3Number;
-    }): Promise<Call>;
-    /**
-     * Gets all leaves from all leaf adapters.
-     * Note: This function is common for any SVK strategy.
-     */
-    getAllLeaves(): LeafData[];
-    /**
-     * Builds and caches the merkle tree from all leaf adapters.
-     * Note: This function is common for any SVK strategy.
-     */
     getMerkleTree(): StandardMerkleTree;
-    /**
-     * Gets the merkle root of the tree.
-     * Note: This function is common for any SVK strategy.
-     */
     getMerkleRoot(): string;
+    getProofs<T>(id: string): {
+        proofs: string[];
+        callConstructor: GenerateCallFn<T>;
+    };
     /**
-     * Combines proofs and manage calls into a single Starknet call.
-     * Note: This function is common for any SVK strategy.
+     * Calculates user realized APY based on trueSharesBasedAPY method.
+     * Returns the APY as a number.
      */
-    getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
     /**
-     * Creates a call to set the merkle root on the manager contract.
-     * Note: This function is common for any SVK strategy.
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
      */
-    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    getTVL(): Promise<SingleTokenInfo>;
+    getUnusedBalance(): Promise<SingleTokenInfo>;
+    protected getVesuAUM(adapter: VesuAdapter): Promise<Web3Number>;
+    getPrevAUM(): Promise<Web3Number>;
+    getAUM(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: {
+            id: string;
+            aum: Web3Number;
+        }[];
+    }>;
+    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
     /**
-     * Returns a tag for logging purposes.
-     * Should be overridden by subclasses to provide strategy-specific tags.
+     * Gets an adapter by its ID from the metadata
      */
-    abstract getTag(): string;
+    getAdapter(id: string): BaseAdapter;
     /**
-     * Returns the positions in the vault.
-     * @returns An array of VaultPosition objects representing the positions in the vault.
+     * Calculates net APY for the strategy
+     * @returns Promise with net APY and splits
      */
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getHealthFactors(): Promise<number[]>;
     netAPY(): Promise<{
         net: number;
         splits: {
@@ -2129,555 +1529,300 @@ declare abstract class SVKStrategy<S extends UniversalStrategySettings> extends
             id: string;
         }[];
     }>;
-    getPrevAUM(): Promise<Web3Number>;
-    maxDepositables(): Promise<PositionInfo[]>;
-    maxWithdrawables(): Promise<PositionInfo[]>;
+    getVesuAdapters(): VesuAdapter[];
+    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    getManageCall(proofIds: string[], manageCalls: ManageCall[]): Call;
+    getVesuModifyPositionCalls(params: {
+        isLeg1: boolean;
+        isDeposit: boolean;
+        depositAmount: Web3Number;
+        debtAmount: Web3Number;
+    }): UniversalManageCall[];
+    getTag(): string;
+    /**
+     * Gets LST APR for the strategy's underlying asset from Endur API
+     * @returns Promise<number> The LST APR (not divided by 1e18)
+     */
+    getLSTAPR(address: ContractAddr): Promise<number>;
+    getVesuHealthFactors(blockNumber?: BlockIdentifier): Promise<number[]>;
+    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
+    private getNewHealthFactor;
+    /**
+     *
+     * @param vesuAdapter
+     * @param currentHf
+     * @param isDeposit if true, attempt by adding collateral, else by repaying
+     * @returns
+     */
+    private getLegRebalanceAmount;
+    getVesuModifyPositionCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call>;
+    getBringLiquidityCall(params: {
+        amount: Web3Number;
+    }): Promise<Call>;
+    getPendingRewards(): Promise<HarvestInfo[]>;
+    getHarvestCall(): Promise<{
+        call: Call;
+        reward: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+    getRebalanceCall(params: {
+        isLeg1toLeg2: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
+}
+declare enum UNIVERSAL_MANAGE_IDS {
+    FLASH_LOAN = "flash_loan_init",
+    VESU_LEG1 = "vesu_leg1",
+    VESU_LEG2 = "vesu_leg2",
+    APPROVE_TOKEN1 = "approve_token1",
+    APPROVE_TOKEN2 = "approve_token2",
+    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
+    BRING_LIQUIDITY = "bring_liquidity",
+    DEFISPRING_REWARDS = "defispring_rewards",
+    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
+    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
 }
+declare enum UNIVERSAL_ADAPTERS {
+    COMMON = "common_adapter",
+    VESU_LEG1 = "vesu_leg1_adapter",
+    VESU_LEG2 = "vesu_leg2_adapter"
+}
+declare function getContractDetails(settings: UniversalStrategySettings): {
+    address: ContractAddr;
+    name: string;
+}[];
+declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
 
 interface HyperLSTStrategySettings extends UniversalStrategySettings {
     borrowable_assets: TokenInfo[];
     underlyingToken: TokenInfo;
-    quoteAmountToFetchPrice: Web3Number;
-    targetHealthFactor: number;
-    minHealthFactor: number;
-    aumOracle: ContractAddr;
 }
-declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
+declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
     private quoteAmountToFetchPrice;
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>);
+    asset(): TokenInfo;
     getTag(): string;
-    getVesuSameTokenAdapter(): VesuMultiplyAdapter;
-    getVesuAdapters(): VesuMultiplyAdapter[];
+    getVesuSameTokenAdapter(): VesuAdapter;
+    getVesuAdapters(): VesuAdapter[];
+    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
+    getLSTUnderlyingTokenInfo(): TokenInfo;
+    getLSTDexPrice(): Promise<number>;
+    getAvnuSwapMultiplyCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<{
+        call: Call | undefined;
+        vesuAdapter: VesuAdapter;
+    }>;
+    _getAvnuDepositSwapLegCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+        minHF: number;
+        vesuAdapter: VesuAdapter;
+    }): Promise<Call | undefined>;
+    getLSTMultiplierRebalanceCall(): Promise<{
+        shouldRebalance: boolean;
+        manageCalls: {
+            vesuAdapter: VesuAdapter;
+            manageCall: Call;
+        }[];
+    }>;
+    _getLSTMultiplierRebalanceCall(vesuAdapter: VesuAdapter): Promise<{
+        shouldRebalance: boolean;
+        manageCall: Call | undefined;
+    }>;
+    protected getVesuAUM(adapter: VesuAdapter): Promise<Web3Number>;
+    private _getMinOutputAmountLSTBuy;
+    private _getMinOutputAmountLSTSell;
     /**
      * Uses vesu's multiple call to create leverage on LST
      * Deposit amount is in LST
      * @param params
      */
-    getFundManagementCall(params: {
+    getVesuMultiplyCall(params: {
         isDeposit: boolean;
         leg1DepositAmount: Web3Number;
-    }): Promise<Call[] | null>;
-    getLSTUnderlyingTokenInfo(): TokenInfo;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
-    }>;
-}
-declare const AUDIT_URL = "https://docs.troves.fi/p/security#starknet-vault-kit";
-declare function getFAQs(lstSymbol: string, underlyingSymbol: string, isLST: boolean): FAQ[];
-declare const _riskFactor: RiskFactor[];
-declare function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string): string[];
-declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
-
-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;
+        maxEkuboPriceImpact?: number;
+    }): Promise<Call[]>;
+    getMaxBorrowableAmount(params?: {
+        isAPYComputation: boolean;
+    }): Promise<{
+        netMaxBorrowableAmount: Web3Number;
+        maxBorrowables: {
+            amount: Web3Number;
+            dexSwappableAmount: Web3Number;
+            maxBorrowableAmount: Web3Number;
+            borrowableAsset: TokenInfo;
+        }[];
     }>;
-    abstract moveAssets(params: {
-        from: string;
-        to: string;
+    getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number): Promise<Web3Number>;
+    getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean): Promise<{
         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;
-}
-declare class VesuExtendedMultiplierStrategy<S extends VesuExtendedStrategySettings> extends SVKStrategy<S> implements Operations {
-    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;
+        dexSwappableAmount: Web3Number;
+        maxBorrowableAmount: Web3Number;
+        borrowableAsset: TokenInfo;
     }>;
-    shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<Call[]>;
-    moveAssets(params: {
-        amount: Web3Number;
-        from: string;
-        to: string;
-    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<{
-        calls: Call[];
-        status: boolean;
+    /**
+     * Gets LST APR for the strategy's underlying asset from Endur API
+     * @returns Promise<number> The LST APR (not divided by 1e18)
+     */
+    getLSTAPR(_address: ContractAddr): Promise<number>;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
     }>;
-    handleDeposit(): Promise<{
-        extendedAmountInBTC: Web3Number;
-        calls: Call[];
+    maxNewDeposits(params?: {
+        isAPYComputation: boolean;
+    }): Promise<number>;
+    /**
+     * Gets Vesu APYs for all positions
+     * @returns Object with positions, baseAPYs, and rewardAPYs
+     */
+    getVesuAPYs(): Promise<{
+        positions: VaultPosition[];
+        baseAPYs: number[];
+        rewardAPYs: number[];
     }>;
-    checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter): Promise<boolean>;
-    handleWithdraw(amount: Web3Number): Promise<{
-        calls: Call[];
-        status: boolean;
+    /**
+     * Returns net APY based on base APYs, reward APYs, weights, and AUM
+     * @param baseAPYs Array of base APY values
+     * @param rewardAPYs Array of reward APY values
+     * @param weights Array of weights for each position
+     * @param aum Total assets under management
+     * @returns Object with net APY and splits
+     */
+    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], aum: Web3Number): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
     }>;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: PositionInfo[];
+    protected getUnusedBalanceAPY(): Promise<{
+        apy: number;
+        weight: number;
     }>;
+    getLSTExchangeRate(): Promise<number>;
+    /**
+     *
+     * @param params marginAmount is in LST, debtAmount is in underlying
+     */
+    getModifyLeverCall(params: {
+        marginAmount: Web3Number;
+        debtAmount: Web3Number;
+        lstDexPriceInUnderlying: number;
+        isIncrease: boolean;
+        maxEkuboPriceImpact: number;
+    }): Promise<Call[]>;
 }
-declare const VesuExtendedTestStrategies: (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number) => IStrategyMetadata<VesuExtendedStrategySettings>[];
+declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
 
-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;
-        })[];
+/**
+ * Filter option definition
+ */
+interface FilterOption {
+    id: string;
+    label: string;
+    icon?: string;
+}
+/**
+ * Strategy filter metadata - defines what filters are available
+ */
+interface StrategyFilterMetadata {
+    assets: FilterOption[];
+    protocols: FilterOption[];
+    categories: FilterOption[];
+    quickFilters: FilterOption[];
+}
+/**
+ * Strategy type enum
+ */
+declare enum StrategyType {
+    EKUBO_CL = "ekubo",
+    UNIVERSAL = "universal",
+    HYPER_LST = "hyper-lst",
+    VESU_REBALANCE = "vesu-rebalance",
+    SENSEI = "sensei"
+}
+/**
+ * Strategy metadata extracted from IStrategyMetadata
+ */
+interface StrategyMetadata {
+    id: string;
+    name: string;
+    type: StrategyType;
+    assets: string[];
+    protocols: string[];
+    category: string;
+    tags: string[];
+    curator?: {
+        name: string;
+        logo: string;
     };
-};
-
+    isRetired: boolean;
+}
 /**
- * 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
+ * Strategy registry entry
  */
-declare const returnFormattedAmount: (amount: number, toTokenDecimals: number) => string;
+interface StrategyRegistryEntry<T = any> {
+    metadata: IStrategyMetadata<T>;
+    type: StrategyType;
+}
 /**
- * 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
+ * Build strategy registry from SDK strategies
  */
-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 function buildStrategyRegistry(): StrategyRegistryEntry[];
 /**
- * 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
+ * Get all strategy metadata from registry
  */
-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>;
+declare function getAllStrategyMetadata(): StrategyMetadata[];
 /**
- * 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
+ * Get filter metadata - defines available filters and their options
  */
-declare const calculateVesuLeverage: () => number;
+declare function getFilterMetadata(): StrategyFilterMetadata;
 /**
- * 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
+ * Get live strategies (filter out retired)
  */
-declare const calculateExtendedLevergae: () => number;
+declare function getLiveStrategies(): 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 strategies by type
  */
-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 getStrategiesByType(type: StrategyType): StrategyRegistryEntry[];
+
 /**
- * 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
+ * SDK Strategy Factory
+ *
+ * Creates SDK strategy instances from metadata.
  */
-declare const calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number | undefined, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, usdcDecimals: number) => {
-    deltadebtAmountUnits: string;
-} | {
-    deltadebtAmountUnits: null;
-};
+
+declare enum FactoryStrategyType {
+    UNIVERSAL = "UNIVERSAL",
+    EKUBO_CL = "EKUBO_CL",
+    HYPER_LST = "HYPER_LST",
+    VESU_REBALANCE = "VESU_REBALANCE",
+    SENSEI = "SENSEI"
+}
+declare function createUniversalStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>): UniversalStrategy<UniversalStrategySettings>;
+declare function createEkuboCLStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>): EkuboCLVault;
+declare function createHyperLSTStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>): UniversalLstMultiplierStrategy;
+declare function createVesuRebalanceStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>): VesuRebalance;
+declare function createSenseiStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>): SenseiVault;
 /**
- * calculate the amount to deposit on extended when incurring losses
- * @param client - The client
- * @returns The amount to deposit on extended when incurring losses
+ * Determines the strategy type from metadata by inspecting the additionalInfo structure
  */
-declare const calculateAmountDepositOnExtendedWhenIncurringLosses: (client: ExtendedWrapper) => Promise<Web3Number | null>;
-declare const calculateExposureDelta: (exposure_extended: number, exposure_vesu: number) => number;
+declare function getStrategyTypeFromMetadata(metadata: IStrategyMetadata<any>): FactoryStrategyType;
 /**
- * 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
+ * Generic factory function that creates SDK strategy instances based on 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 createStrategy(type: FactoryStrategyType, config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<any>): VesuRebalance | EkuboCLVault | SenseiVault | UniversalStrategy<UniversalStrategySettings>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -2703,8 +1848,7 @@ interface EkuboQuote {
 declare class EkuboQuoter {
     private readonly config;
     ENDPOINT: string;
-    tokenMarketData: TokenMarketData;
-    constructor(config: IConfig, pricer: PricerBase);
+    constructor(config: IConfig);
     /**
      *
      * @param fromToken
@@ -2713,9 +1857,6 @@ declare class EkuboQuoter {
      * @returns
      */
     getQuote(fromToken: string, toToken: string, amount: Web3Number, retry?: number): 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>;
     /**
      * Formats Ekubo response for Vesu multiple use
      * @param quote
@@ -2725,6 +1866,16 @@ declare class EkuboQuoter {
     getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[];
 }
 
+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 FatalError extends Error {
     constructor(message: string, err?: Error);
 }
@@ -2743,6 +1894,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;
 }
@@ -2776,9 +1928,6 @@ declare class LSTAPRService {
     private static cache;
     private static cacheTimestamp;
     private static readonly CACHE_DURATION;
-    static lstMapping: Record<string, TokenInfo>;
-    static isLST(address: ContractAddr): boolean;
-    static getUnderlyingFromLST(lstAddress: ContractAddr): TokenInfo;
     /**
      * Fetches LST stats from Endur API with caching
      * @returns Promise<LSTStats[]> Array of LST statistics
@@ -2807,73 +1956,6 @@ declare class LSTAPRService {
     static clearCache(): void;
 }
 
-/**
- * Midas module for interacting with Midas API
- * Provides functions to get APY, price, and TVL data for Midas tokens
- */
-declare class Midas {
-    private static readonly CONTRACT_TO_SYMBOL;
-    private static readonly BASE_URL;
-    /**
-     * Check if a contract address is supported by Midas
-     * @param contractAddr The contract address to check
-     * @returns True if the contract address is supported
-     */
-    static isSupported(contractAddr: ContractAddr): boolean;
-    /**
-     * Get the Midas symbol for a given contract address
-     * @param contractAddr The contract address to look up
-     * @returns The Midas symbol for the contract
-     * @throws Error if contract address is not found
-     */
-    static getSymbolFromContract(contractAddr: ContractAddr): string;
-    /**
-     * Get APY data for all Midas tokens
-     * @returns Object with token symbols as keys and APY values as numbers
-     * @throws Error if API request fails
-     */
-    static getAPYs(): Promise<Record<string, number>>;
-    /**
-     * Get APY for a specific token by contract address
-     * @param contractAddr The contract address of the token
-     * @returns The APY value for the token
-     * @throws Error if contract address not found or API request fails
-     */
-    static getAPY(contractAddr: ContractAddr): Promise<number>;
-    /**
-     * Get price data for a specific token
-     * @param contractAddr The contract address of the token
-     * @param timestampFrom Optional start timestamp (defaults to 30 days ago)
-     * @param timestampTo Optional end timestamp (defaults to now)
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns The latest price for the token
-     * @throws Error if contract address not found or API request fails
-     */
-    static getPrice(contractAddr: ContractAddr, timestampFrom?: number, timestampTo?: number, environment?: string): Promise<number>;
-    /**
-     * Get TVL data for all tokens
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns Object with TVL data including totalTvl and tokenTvl
-     * @throws Error if API request fails
-     */
-    static getTVLData(environment?: string): Promise<{
-        lastUpdatedAt: string;
-        totalTvl: number;
-        tokenTvl: Record<string, any>;
-    }>;
-    /**
-     * Get TVL for a specific token by contract address
-     * @param contractAddr The contract address of the token
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns The TVL data for the token (USD and native amounts)
-     * @throws Error if contract address not found or API request fails
-     */
-    static getTVL(contractAddr: ContractAddr, environment?: string): Promise<{
-        usd: number;
-        native: number;
-    } | number>;
-}
-
 declare class TelegramNotif {
     private subscribers;
     readonly bot: TelegramBot;
@@ -2910,7 +1992,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>;
@@ -2937,6 +2019,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;
@@ -2944,6 +2027,7 @@ declare const Deployer: {
     prepareMultiDeployContracts: typeof prepareMultiDeployContracts;
     executeDeployCalls: typeof executeDeployCalls;
     executeTransactions: typeof executeTransactions;
+    myWaitForTransaction: typeof myWaitForTransaction;
 };
 
 /**
@@ -3024,4 +2108,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 { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, EkuboPricer, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FactoryStrategyType, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, InstantWithdrawalVault, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, MyNumber, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerBase, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionExpectedTime, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type StrategyAlert, type StrategyCapabilities, StrategyCategory, type StrategyFilterMetadata, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, buildStrategyRegistry, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getContractDetails, getDefaultStoreConfig, getFilterMetadata, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };