@strkfarm/sdk 1.1.70 → 2.0.0-dev.2

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Contract, Uint256, Call, Account, CairoCustomEnum, RawArgs } from 'starknet';
+import { RpcProvider, BlockIdentifier, Contract, Call, Account, CairoCustomEnum, Uint256, 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,6 +51,7 @@ declare class ContractAddr {
     static eqString(a: string, b: string): boolean;
     toString(): string;
     toBigInt(): bigint;
+    shortString(left?: number, right?: number): string;
 }
 
 declare enum RiskType {
@@ -169,11 +170,16 @@ interface VaultPosition {
     usdValue: number;
     token: TokenInfo;
     remarks: string;
+    protocol: IProtocol;
 }
 declare const Protocols: {
+    NONE: IProtocol;
     VESU: IProtocol;
     ENDUR: IProtocol;
     EXTENDED: IProtocol;
+    EKUBO: IProtocol;
+    AVNU: IProtocol;
+    VAULT: IProtocol;
 };
 
 interface ILendingMetadata {
@@ -228,13 +234,6 @@ declare abstract class Initializable {
     waitForInitilisation(): Promise<void>;
 }
 
-declare abstract class PricerBase {
-    readonly config: IConfig;
-    readonly tokens: TokenInfo[];
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    getPrice(tokenSymbol: string): Promise<PriceInfo>;
-}
-
 interface PriceInfo {
     price: number;
     timestamp: Date;
@@ -246,7 +245,7 @@ declare class Pricer extends PricerBase {
     refreshInterval: number;
     staleTime: number;
     protected methodToUse: {
-        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu';
+        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap';
     };
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -264,130 +263,14 @@ declare class Pricer extends PricerBase {
     _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
     _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
-    _getAvnuPrice(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
     _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
 }
 
-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 {
+declare abstract class PricerBase {
+    readonly config: IConfig;
+    readonly tokens: TokenInfo[];
     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>;
-}
-
-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 {
@@ -402,251 +285,237 @@ declare class CacheClass {
     isCacheValid(key: string): boolean;
 }
 
-interface SingleActionAmount {
-    tokenInfo: TokenInfo;
-    amount: Web3Number;
-}
-interface SingleTokenInfo extends SingleActionAmount {
-    usdValue: number;
+interface LeveledLogMethod {
+    (message: string, ...meta: any[]): void;
+    (message: any): void;
 }
-interface DualActionAmount {
-    token0: SingleActionAmount;
-    token1: SingleActionAmount;
+interface MyLogger {
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    info: LeveledLogMethod;
+    verbose: LeveledLogMethod;
+    debug: LeveledLogMethod;
 }
-interface DualTokenInfo {
-    usdValue: number;
-    token0: SingleTokenInfo;
-    token1: SingleTokenInfo;
+declare const logger: MyLogger;
+
+interface LeafData {
+    id: bigint;
+    readableId: string;
+    data: bigint[];
 }
-interface CacheData {
-    timestamp: number;
-    ttl: number;
-    data: any;
+interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+    format: 'standard-v1';
+    leafEncoding: ValueType[];
 }
-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[]>;
-    getPendingRewards(): Promise<HarvestInfo[]>;
+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 PoolProps {
-    pool_id: ContractAddr;
-    max_weight: number;
-    v_token: ContractAddr;
-}
-interface Change {
-    pool_id: ContractAddr;
-    changeAmt: Web3Number;
-    finalAmt: Web3Number;
-    isDeposit: 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[];
+    };
 }
-interface VesuRebalanceSettings {
-    feeBps: number;
+interface DepositParams {
+    amount: Web3Number;
 }
-interface PoolInfoFull {
-    pool_id: ContractAddr;
-    pool_name: string | undefined;
-    max_weight: number;
-    current_weight: number;
-    v_token: ContractAddr;
+interface WithdrawParams {
     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[]>;
+type GenerateCallFn<T> = (params: T) => Promise<ManageCall[]>;
+type AdapterLeafType<T> = {
+    leaves: LeafData[];
+    callConstructor: GenerateCallFn<T>;
+};
+type LeafAdapterFn<T> = () => AdapterLeafType<T>;
+declare enum APYType {
+    BASE = "base",
+    REWARD = "reward",
+    LST = "lst"
+}
+interface SupportedPosition {
+    asset: TokenInfo;
+    isDebt: boolean;
+}
+interface BaseAdapterConfig {
+    baseToken: TokenInfo;
+    supportedPositions: SupportedPosition[];
+    networkConfig: IConfig;
+    pricer: PricerBase;
+    vaultAllocator: ContractAddr;
+    vaultAddress: ContractAddr;
+}
+type PositionAPY = {
+    apy: number;
+    type: APYType;
+};
+type PositionInfo = {
+    tokenInfo: TokenInfo;
+    amount: Web3Number;
+    usdValue: number;
+    remarks: string;
+    apy: PositionAPY;
+    protocol: IProtocol;
+};
+type PositionAmount = {
+    amount: Web3Number;
+    remarks: string;
+};
+declare abstract class BaseAdapter<DepositParams, WithdrawParams> extends CacheClass {
+    readonly name: string;
+    readonly config: BaseAdapterConfig;
+    readonly protocol: IProtocol;
+    constructor(config: BaseAdapterConfig, name: string, protocol: IProtocol);
     /**
-     * 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
+     * Loop through all supported positions and return amount, usd value, remarks and apy for each
      */
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<starknet.Call[]>;
+    getPositions(): Promise<PositionInfo[]>;
     /**
-     * Returns the underlying asset token of the strategy.
-     * @returns The deposit token supported by this strategy
+     * Implemented by child adapters to compute APY for a given supported position
      */
-    asset(): TokenInfo;
+    protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
     /**
-     * Returns the number of decimals used by the strategy token.
-     * @returns Number of decimals (same as the underlying token)
+     * Implemented by child adapters to fetch amount for a given supported position
      */
-    decimals(): number;
+    protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
     /**
-     * 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
+     * Implemented by child adapters to calculate maximum deposit positions
+     * @param amount Optional amount in baseToken to deposit
      */
-    getUserTVL(user: ContractAddr): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }>;
+    abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
     /**
-     * Calculates the total TVL of the strategy.
-     * @returns Object containing the total amount in token units and USD value
+     * Implemented by child adapters to calculate maximum withdraw positions
      */
-    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;
-    }>;
+    abstract maxWithdraw(): Promise<PositionInfo>;
     /**
-     * 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
+     * Uses pricer to convert an amount of an asset to USD value
      */
-    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;
-    }>;
+    protected getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number>;
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
     /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+     */
+    protected abstract _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    /**
+     * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
      */
-    netAPY(): Promise<number>;
+    protected abstract _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
     /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * Returns deposit leaf adapter using configured proof id
      */
-    netAPYGivenPools(pools: PoolInfoFull[]): Promise<number>;
+    getDepositLeaf(): AdapterLeafType<DepositParams>;
     /**
-     * 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
+     * Returns withdraw leaf adapter using configured proof id
      */
-    getRebalancedPositions(_pools?: PoolInfoFull[]): Promise<{
-        changes: never[];
-        finalPools: never[];
-        isAnyPoolOverMaxWeight?: undefined;
-    } | {
-        changes: Change[];
-        finalPools: PoolInfoFull[];
-        isAnyPoolOverMaxWeight: boolean;
-    }>;
+    getWithdrawLeaf(): AdapterLeafType<WithdrawParams>;
     /**
-     * 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
+     * Implementor must provide deposit call
+     * @param params
      */
-    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[]>;
+    abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
     /**
-     * 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
+     * Implementor must provide withdraw call
+     * @param params
      */
-    getFee(allowedPools: Array<PoolInfoFull>): Promise<Array<{
-        vToken: ContractAddr;
-        fee: Web3Number;
-    }>>;
+    abstract getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    getProofs<T>(isDeposit: boolean, tree: StandardMerkleTree): {
+        proofs: string[][];
+        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
+    };
+    getNetAPY(): Promise<number>;
+    abstract getHealthFactor(): Promise<number>;
+}
+
+interface FlashloanCallParams {
+    amount: Web3Number;
+    data: bigint[];
+}
+interface ApproveCallParams {
+    amount: Web3Number;
+}
+interface AvnuSwapCallParams {
+    props: SwapInfo;
+}
+interface CommonAdapterConfig {
+    id: string;
+    vaultAddress: ContractAddr;
+    vaultAllocator: ContractAddr;
+    manager: ContractAddr;
+    asset: ContractAddr;
+}
+declare class CommonAdapter {
+    config: CommonAdapterConfig;
+    constructor(config: CommonAdapterConfig);
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }, sanitizer?: ContractAddr): LeafData;
+    getFlashloanAdapter(): Promise<AdapterLeafType<FlashloanCallParams>>;
+    getFlashloanCall(params: FlashloanCallParams): Promise<ManageCall[]>;
+    getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveCall(token: ContractAddr, spender: ContractAddr): (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[];
 }
-/**
- * Represents the Vesu Rebalance Strategies.
- */
-declare const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[];
 
 interface EkuboPoolKey {
     token0: ContractAddr;
@@ -728,7 +597,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * Calculates assets before and now in a given token of TVL per share to observe growth
      * @returns {Promise<number>} The weighted average APY across all pools
      */
-    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<number>;
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: '24h' | '7d' | '30d' | '3m'): Promise<APYInfo>;
     getHarvestRewardShares(fromBlock: number, toBlock: number): Promise<Web3Number>;
     balanceOf(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<Web3Number>;
     getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<DualTokenInfo>;
@@ -783,7 +652,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
             usdValue: number;
         };
     }>;
-    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
+    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
     assertValidBounds(bounds: EkuboBounds): void;
     assertValidAmounts(expectedAmounts: any, token0Bal: Web3Number, token1Bal: Web3Number): void;
     getSwapParams(expectedAmounts: any, poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number): {
@@ -803,7 +672,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns {Promise<SwapInfo>}
      *
      */
-    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
+    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
     /**
      * Attempts to rebalance the vault by iteratively adjusting swap amounts if initial attempt fails.
      * Uses binary search approach to find optimal swap amount.
@@ -814,16 +683,10 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
-     * @param MAX_RETRIES - Maximum number of retries (default 40)
-     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
-     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance or max same errors reached
+     * @throws Error if max retries reached without successful rebalance
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number, sameErrorCount?: {
-        count: number;
-        error: null | string;
-    }, MAX_SAME_ERROR_COUNT?: number): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;
@@ -842,8 +705,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
         amount0: Web3Number;
         amount1: Web3Number;
     }>;
-    getPendingRewards(): Promise<HarvestInfo[]>;
-    harvest(acc: Account, maxIterations?: number, priceRatioPrecision?: number, minRewardAmount?: Web3Number): Promise<Call[]>;
+    harvest(acc: Account, maxIterations?: number, priceRatioPrecision?: number): Promise<Call[]>;
     /**
      * @description This funciton requires atleast one of the pool tokens to be reward token
      * i.e. STRK.
@@ -892,175 +754,9 @@ 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): 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>;
-}
-
-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;
+interface VesuPoolsInfo {
+    pools: any[];
+    isErrorPoolsAPI: boolean;
 }
 declare enum VesuAmountType {
     Delta = 0,
@@ -1155,6 +851,7 @@ declare const VesuPools: {
     Genesis: ContractAddr;
     Re7xSTRK: ContractAddr;
     Re7xBTC: ContractAddr;
+    Re7USDCPrime: ContractAddr;
 };
 declare const extensionMap: {
     [key: string]: ContractAddr;
@@ -1163,44 +860,14 @@ declare function getVesuSingletonAddress(vesuPool: ContractAddr): {
     addr: ContractAddr;
     isV2: boolean;
 };
-declare class VesuAdapter extends BaseAdapter {
+declare class VesuAdapter extends CacheClass {
     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): {
@@ -1239,40 +906,1150 @@ declare class VesuAdapter extends BaseAdapter {
     getMaxUtilizationGivenRatePerSecond(interestRateConfig: InterestRateConfig, ratePerSecond: bigint, timeDelta: bigint, last_full_utilization_rate: bigint): bigint;
 }
 
-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[];
-    manageCall: ManageCall;
-    step: UNIVERSAL_MANAGE_IDS;
-}
-interface UniversalStrategySettings {
-    vaultAddress: ContractAddr;
-    manager: ContractAddr;
-    vaultAllocator: ContractAddr;
-    redeemRequestNFT: ContractAddr;
-    aumOracle: ContractAddr;
-    leafAdapters: LeafAdapterFn<any>[];
-    adapters: {
+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;
-        adapter: BaseAdapter;
     }[];
+    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;
+}
+declare class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: VesuMultiplyAdapterConfig;
+    readonly vesuAdapter: VesuAdapter;
+    readonly tokenMarketData: TokenMarketData;
+    constructor(config: VesuMultiplyAdapterConfig);
+    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    maxBorrowableAPY(): Promise<number>;
+    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    maxWithdraw(): Promise<PositionInfo>;
+    protected _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getDepositAdapter(): AdapterLeafType<DepositParams>;
+    getWithdrawAdapter(): AdapterLeafType<WithdrawParams>;
+    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+    private getMultiplyCallCalldata;
+    private getLeverParams;
+    private getWithdrawalCalldata;
+    formatMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams): {
+        action: CairoCustomEnum;
+    };
+    getHealthFactor(): Promise<number>;
+    getNetAPY(): Promise<number>;
+}
+
+/**
+ * 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;
+}
+declare class ExtendedAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+    readonly config: ExtendedAdapterConfig;
+    readonly client: ExtendedWrapper;
+    constructor(config: ExtendedAdapterConfig);
+    protected getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+    protected getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+    maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+    maxWithdraw(): Promise<PositionInfo>;
+    protected _getDepositLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getSwapFromLegacyLeaf(): AdapterLeafType<DepositParams>;
+    protected _getSwapFromLegacyLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    protected _getWithdrawLeaf(): {
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+        sanitizer: ContractAddr;
+        id: string;
+    }[];
+    getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+    getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): {
+        proofs: string[][];
+        callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams>;
+    };
+    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, 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>[];
+
+interface UniversalManageCall {
+    proofs: string[];
+    manageCall: ManageCall;
+    step: UNIVERSAL_MANAGE_IDS;
+}
+interface UniversalStrategySettings {
+    vaultAddress: ContractAddr;
+    manager: ContractAddr;
+    vaultAllocator: ContractAddr;
+    redeemRequestNFT: ContractAddr;
+    leafAdapters: LeafAdapterFn<any>[];
+    adapters: {
+        id: string;
+        adapter: BaseAdapter<DepositParams, WithdrawParams>;
+    }[];
 }
 declare enum AUMTypes {
     FINALISED = "finalised",
     DEFISPRING = "defispring"
 }
-declare class UniversalStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+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 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> {
     /** Contract address of the strategy */
     readonly address: ContractAddr;
     /** Pricer instance for token price calculations */
@@ -1281,38 +2058,63 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
     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>);
-    getMerkleTree(): StandardMerkleTree;
-    getMerkleRoot(): string;
-    getProofs<T>(id: string): {
-        proofs: string[];
-        callConstructor: GenerateCallFn<T>;
-    };
-    getAdapter(id: string): BaseAdapter;
+    /**
+     * Returns the asset token for this strategy
+     */
     asset(): TokenInfo;
-    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
-    withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
     /**
-     * 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
+     * Returns the unused balance in the vault allocator.
+     * Note: This function is common for any SVK strategy.
      */
-    getUserTVL(user: ContractAddr): Promise<{
-        tokenInfo: TokenInfo;
+    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;
-        usdValue: number;
-    }>;
-    getVesuAPYs(): Promise<{
-        baseAPYs: number[];
-        rewardAPYs: number[];
-        positions: VaultPosition[];
-    }>;
+    }): Promise<Call>;
     /**
-     * Calculates the weighted average APY across all pools based on USD value.
-     * @returns {Promise<number>} The weighted average APY across all pools
+     * 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;
+    /**
+     * Combines proofs and manage calls into a single Starknet call.
+     * Note: This function is common for any SVK strategy.
+     */
+    getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call;
+    /**
+     * Creates a call to set the merkle root on the manager contract.
+     * Note: This function is common for any SVK strategy.
+     */
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    /**
+     * Returns a tag for logging purposes.
+     * Should be overridden by subclasses to provide strategy-specific tags.
+     */
+    abstract getTag(): string;
+    /**
+     * Returns the positions in the vault.
+     * @returns An array of VaultPosition objects representing the positions in the vault.
      */
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getHealthFactors(): Promise<number[]>;
     netAPY(): Promise<{
         net: number;
         splits: {
@@ -1320,210 +2122,555 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
             id: string;
         }[];
     }>;
-    protected returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number): Promise<{
-        net: number;
-        splits: {
-            apy: number;
-            id: string;
-        }[];
-    }>;
-    protected getUnusedBalanceAPY(): Promise<{
-        apy: number;
-        weight: number;
-    }>;
-    private computeAPY;
-    /**
-       * Calculates the total TVL of the strategy.
-       * @returns Object containing the total amount in token units and USD value
-    */
-    getTVL(): Promise<{
-        tokenInfo: TokenInfo;
-        amount: Web3Number;
-        usdValue: number;
-    }>;
-    getUnusedBalance(): Promise<SingleTokenInfo>;
-    protected getVesuAUM(adapter: VesuAdapter): Promise<Web3Number>;
     getPrevAUM(): Promise<Web3Number>;
-    getAUM(): Promise<{
-        net: SingleTokenInfo;
-        prevAum: Web3Number;
-        splits: {
-            id: string;
-            aum: Web3Number;
-        }[];
-    }>;
-    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
-    getVesuAdapters(): VesuAdapter[];
-    getVesuPositions(blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
-    getVaultPositions(): Promise<VaultPosition[]>;
-    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
-    getManageCall(proofIds: string[], manageCalls: ManageCall[]): Call;
-    getVesuModifyPositionCalls(params: {
-        isLeg1: boolean;
-        isDeposit: boolean;
-        depositAmount: Web3Number;
-        debtAmount: Web3Number;
-    }): UniversalManageCall[];
-    getTag(): string;
-    /**
-     * Gets LST APR for the strategy's underlying asset from Endur API
-     * @returns Promise<number> The LST APR (not divided by 1e18)
-     */
-    getLSTAPR(address: ContractAddr): Promise<number>;
-    getVesuHealthFactors(blockNumber?: BlockIdentifier): Promise<number[]>;
-    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
-    private getNewHealthFactor;
-    /**
-     *
-     * @param vesuAdapter
-     * @param currentHf
-     * @param isDeposit if true, attempt by adding collateral, else by repaying
-     * @returns
-     */
-    private getLegRebalanceAmount;
-    getVesuModifyPositionCall(params: {
-        isDeposit: boolean;
-        leg1DepositAmount: Web3Number;
-    }): Promise<Call>;
-    getBringLiquidityCall(params: {
-        amount: Web3Number;
-    }): Promise<Call>;
-    getPendingRewards(): Promise<HarvestInfo[]>;
-    getHarvestCall(): Promise<{
-        call: Call;
-        reward: Web3Number;
-        tokenInfo: TokenInfo;
-    }>;
-    getRebalanceCall(params: {
-        isLeg1toLeg2: boolean;
-        amount: Web3Number;
-    }): Promise<Call>;
-}
-declare enum UNIVERSAL_MANAGE_IDS {
-    FLASH_LOAN = "flash_loan_init",
-    VESU_LEG1 = "vesu_leg1",
-    VESU_LEG2 = "vesu_leg2",
-    APPROVE_TOKEN1 = "approve_token1",
-    APPROVE_TOKEN2 = "approve_token2",
-    APPROVE_BRING_LIQUIDITY = "approve_bring_liquidity",
-    BRING_LIQUIDITY = "bring_liquidity",
-    DEFISPRING_REWARDS = "defispring_rewards",
-    APPROVE_SWAP_TOKEN1 = "approve_swap_token1",
-    AVNU_SWAP_REWARDS = "avnu_swap_rewards"
-}
-declare enum UNIVERSAL_ADAPTERS {
-    COMMON = "common_adapter",
-    VESU_LEG1 = "vesu_leg1_adapter",
-    VESU_LEG2 = "vesu_leg2_adapter"
+    maxDepositables(): Promise<PositionInfo[]>;
+    maxWithdrawables(): Promise<PositionInfo[]>;
 }
-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 extends UniversalStrategy<HyperLSTStrategySettings> {
+declare class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
     private quoteAmountToFetchPrice;
-    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>);
-    asset(): TokenInfo;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
     getTag(): string;
-    getVesuSameTokenAdapter(): VesuAdapter;
-    getVesuAdapters(): VesuAdapter[];
-    protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
-    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;
+    getVesuSameTokenAdapter(): VesuMultiplyAdapter;
+    getVesuAdapters(): VesuMultiplyAdapter[];
     /**
      * Uses vesu's multiple call to create leverage on LST
      * Deposit amount is in LST
      * @param params
      */
-    getVesuMultiplyCall(params: {
+    getFundManagementCall(params: {
         isDeposit: boolean;
         leg1DepositAmount: Web3Number;
-        maxEkuboPriceImpact?: number;
-    }): Promise<Call[]>;
+    }): Promise<Call[] | null>;
     getLSTUnderlyingTokenInfo(): TokenInfo;
-    getMaxBorrowableAmount(params?: {
-        isAPYComputation: boolean;
-    }): Promise<{
-        netMaxBorrowableAmount: Web3Number;
-        maxBorrowables: {
-            amount: Web3Number;
-            dexSwappableAmount: Web3Number;
-            maxBorrowableAmount: Web3Number;
-            borrowableAsset: TokenInfo;
-        }[];
+    getAUM(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: PositionInfo[];
     }>;
-    getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number): Promise<Web3Number>;
-    getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean): Promise<{
+}
+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;
+    }>;
+    abstract moveAssets(params: {
+        from: string;
+        to: string;
         amount: Web3Number;
-        dexSwappableAmount: Web3Number;
-        maxBorrowableAmount: Web3Number;
-        borrowableAsset: TokenInfo;
+    }, 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;
-        }[];
+    abstract handleDeposit(): Promise<{
+        extendedAmountInBTC: Web3Number;
+        calls: Call[];
     }>;
-    maxNewDeposits(params?: {
-        isAPYComputation: boolean;
-    }): Promise<number>;
-    protected getUnusedBalanceAPY(): Promise<{
-        apy: number;
-        weight: number;
+    abstract handleWithdraw(amount: Web3Number): Promise<{
+        calls: Call[];
+        status: boolean;
     }>;
-    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 HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
+
+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;
+    }>;
+    shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<Call[]>;
+    moveAssets(params: {
+        amount: Web3Number;
+        from: string;
+        to: string;
+    }, extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter): Promise<{
+        calls: Call[];
+        status: boolean;
+    }>;
+    handleDeposit(): Promise<{
+        extendedAmountInBTC: Web3Number;
+        calls: Call[];
+    }>;
+    checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter): Promise<boolean>;
+    handleWithdraw(amount: Web3Number): Promise<{
+        calls: Call[];
+        status: boolean;
+    }>;
+    getAUM(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: PositionInfo[];
+    }>;
+}
+declare const VesuExtendedTestStrategies: (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number) => IStrategyMetadata<VesuExtendedStrategySettings>[];
+
+declare const AddressesConfig: {
+    readonly tokens: {
+        readonly USDC: {
+            readonly address: "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
+            readonly decimals: 6;
+        };
+        readonly WBTC: {
+            readonly address: "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
+            readonly decimals: 8;
+        };
+    };
+    readonly contracts: {
+        readonly EXTENDED: "0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470";
+        readonly MULTIPLY: "0x07964760e90baa28841ec94714151e03fbc13321797e68a874e88f27c9d58513";
+    };
+    readonly wallet: {
+        readonly address: string;
+    };
+};
+declare const ExtendedConfig: {
+    readonly baseUrl: string;
+    readonly marketName: "BTC-USD";
+    readonly maintenanceMargin: 0.01;
+    readonly precision: 5;
+    readonly fees: number;
+    readonly minPositionSize: 0.0001;
+};
+declare const VesuConfig: {
+    readonly poolId: "0x02eef0c13b10b487ea5916b54c0a7f98ec43fb3048f60fdeedaf5b08f6f88aaf";
+    readonly maxLtv: 0.8428;
+    readonly maxLiquidationRatio: 0.86;
+    readonly targetHealthFactor: number;
+    readonly ekubo: {
+        readonly endpoint: "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}";
+        readonly priceMaxSlippage: number;
+    };
+    readonly avnu: {
+        readonly api: "https://starknet.api.avnu.fi/swap/v2/quotes";
+    };
+    readonly minDebtForVesuRebalacing: number;
+};
+declare const AbisConfig: {
+    readonly vesu: {
+        readonly multiply: ({
+            type: string;
+            name: string;
+            interface_name: string;
+            members?: undefined;
+            items?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            members: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            items?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            items: {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                }[];
+                outputs: {
+                    type: string;
+                }[];
+                state_mutability: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            variants: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            inputs: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            variants?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            members: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            items?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            variants: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+        })[];
+        readonly pool: ({
+            type: string;
+            name: string;
+            interface_name: string;
+            members?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            members: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            variants: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            items: {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                }[];
+                outputs: {
+                    type: string;
+                }[];
+                state_mutability: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            inputs: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            members: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            variants: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+        })[];
+    };
+    readonly extended: {
+        readonly contract: ({
+            type: string;
+            name: string;
+            interface_name: string;
+            members?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            members: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            variants: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            items: {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                }[];
+                outputs: {
+                    type: string;
+                }[];
+                state_mutability: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            variants?: undefined;
+            inputs?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            inputs: {
+                name: string;
+                type: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            kind?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            members: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            variants?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+        } | {
+            type: string;
+            name: string;
+            kind: string;
+            variants: {
+                name: string;
+                type: string;
+                kind: string;
+            }[];
+            interface_name?: undefined;
+            members?: undefined;
+            items?: undefined;
+            inputs?: undefined;
+        })[];
+    };
+};
+
+/**
+ * Function to return formatted amount to BigInt
+ * Converts a decimal amount to the proper format for blockchain transactions
+ * @param {number} amount - The decimal amount to convert
+ * @param {number} fromTokenDecimals - The decimal precision of the token
+ * @returns {string} The formatted amount as a hexadecimal string
+ */
+declare const returnFormattedAmount: (amount: number, toTokenDecimals: number) => string;
+/**
+ * calculates the amount to distribute to 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
+ */
+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;
+}>;
+/**
+ * calculate the amount distribution for withdrawal
+ * @param amount - The amount to withdraw
+ * @param client - The client
+ * @param marketName - The market name
+ * @returns {object} Object containing avnu_amount and extended_amount
+ */
+declare const calculateAmountDistributionForWithdrawal: (amountInUsdc: Web3Number, collateralPrice: number, collateralUnits: Web3Number, extendedPosition: Position[] | null) => Promise<{
+    vesu_amount: Web3Number;
+    extended_amount: Web3Number;
+    extended_leverage: number;
+    vesu_leverage: number;
+} | null>;
+/**
+ * calculate the leverage required for Avnu
+ * calculates the optimal leverage for Avnu based on LTV ratios and price drop protection
+ * @returns {number} The calculated leverage value
+ */
+declare const calculateVesuLeverage: () => number;
+/**
+ * calculate leverage for extended
+ * calculates the maximum safe leverage for Extended based on maintenance margin and price drop protection
+ * @returns {number} The calculated leverage value
+ */
+declare const calculateExtendedLevergae: () => number;
+/**
+ * calculates the debt amount for leverage operations
+ * Determines how much debt to add or remove based on collateral changes and target health factor
+ * @param {Web3Number} collateralAmount - Current collateral amount
+ * @param {Web3Number} debtAmount - Current debt amount
+ * @param {number} debtPrice - Current price of the debt token
+ * @param {number} maxLtv - Maximum loan-to-value ratio (default: MAX_LTV_BTC_USDC)
+ * @param {number} addedAmount - Amount being added to collateral
+ * @param {number} collateralPrice - Current price of the collateral token
+ * @param {boolean} isDeposit - Whether this is a deposit (true) or withdrawal (false)
+ * @returns {object} Object containing deltadebtAmountUnits and isIncrease flag
+ */
+declare const calculateDebtAmount: (collateralAmount: Web3Number, debtAmount: Web3Number, debtPrice: number, maxLtv: number | undefined, addedAmount: Web3Number, // this is in btc
+collateralPrice: number, isDeposit: boolean) => {
+    deltadebtAmountUnits: Web3Number;
+    isIncrease: boolean;
+} | {
+    deltadebtAmountUnits: null;
+    isIncrease: null;
+};
+/**
+ * calculate the debt amount to be repaid for withdrawal
+ * @param debtAmount in debt units
+ * @param collateralAmount in collateral units
+ * @param maxLtv in percentage
+ * @param withdrawalAmount in collateral units
+ * @param collateralPrice in usd
+ * @param debtPrice in usd
+ * @returns deltadebtAmountUnits in debt units
+ *          isIncrease: true if the debt amount is increasing, false if it is decreasing
+ */
+declare const calculateDebtReductionAmountForWithdrawal: (debtAmount: Web3Number, collateralAmount: Web3Number, maxLtv: number | undefined, withdrawalAmount: Web3Number, collateralPrice: number, debtPrice: number, usdcDecimals: number) => {
+    deltadebtAmountUnits: string;
+} | {
+    deltadebtAmountUnits: null;
+};
+/**
+ * calculate the amount to deposit on extended when incurring losses
+ * @param client - The client
+ * @returns The amount to deposit on extended when incurring losses
+ */
+declare const calculateAmountDepositOnExtendedWhenIncurringLosses: (client: ExtendedWrapper) => Promise<Web3Number | null>;
+declare const calculateExposureDelta: (exposure_extended: number, exposure_vesu: number) => number;
+/**
+ * calculate the delta percentage between the current btc price and the last btc price
+ * @param {number} btcPrice - The current btc price
+ * @param {number} lastBtcPrice - The last btc price
+ * @returns {number} The delta percentage
+ */
+declare const calculateBTCPriceDelta: (btcPrice: number, lastBtcPrice: number) => number;
+declare const calculateVesUPositionSizeGivenExtended: (extendedPositonValue: number, extendedHoldingAmount: Web3Number, collateralAmount: Web3Number, collateralPrice: number) => {
+    vesuAmountInUsd: string;
+    vesuAmountInBTC: Web3Number;
+    extendedAmountInBTC: Web3Number;
+};
 
 interface EkuboRouteNode {
     pool_key: {
@@ -1549,7 +2696,8 @@ interface EkuboQuote {
 declare class EkuboQuoter {
     private readonly config;
     ENDPOINT: string;
-    constructor(config: IConfig);
+    tokenMarketData: TokenMarketData;
+    constructor(config: IConfig, pricer: PricerBase);
     /**
      *
      * @param fromToken
@@ -1558,6 +2706,9 @@ 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
@@ -1618,6 +2769,9 @@ 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
@@ -1646,6 +2800,73 @@ 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;
@@ -1709,7 +2930,6 @@ 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;
@@ -1717,7 +2937,6 @@ declare const Deployer: {
     prepareMultiDeployContracts: typeof prepareMultiDeployContracts;
     executeDeployCalls: typeof executeDeployCalls;
     executeTransactions: typeof executeTransactions;
-    myWaitForTransaction: typeof myWaitForTransaction;
 };
 
 /**
@@ -1798,4 +3017,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type ApproveCallParams, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FatalError, 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, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, 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, extensionMap, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, toBigInt };
+export { type APYInfo, APYType, AUDIT_URL, AUMTypes, AVNU_EXCHANGE, AVNU_EXCHANGE_FOR_LEGACY_USDC, AVNU_LEGACY_SANITIZER, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, AbisConfig, type 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 };