@strkfarm/sdk 2.0.0-staging.1 → 2.0.0-staging.11

package/dist/index.d.ts

@@ -53,6 +53,33 @@ declare class ContractAddr {
     toBigInt(): bigint;
 }
 
+declare const customInspectSymbol: unique symbol;
+declare class MyNumber {
+    bigNumber: BigNumber;
+    decimals: number;
+    constructor(bigNumber: string, decimals: number);
+    static fromEther(num: string, decimals: number): MyNumber;
+    static fromZero(): MyNumber;
+    toString(): string;
+    toEtherStr(): string;
+    toFixedStr(decimals: number): string;
+    toEtherToFixedDecimals(decimals: number): string;
+    isZero(): boolean;
+    /**
+     *
+     * @param amountEther in token terms without decimal e.g. 1 for 1 STRK
+     * @param command BigNumber compare funds. e.g. gte, gt, lt
+     * @returns
+     * @dev Add more commands as needed
+     */
+    compare(amountEther: string, command: "gte" | "gt" | "lt"): boolean;
+    operate(command: "div" | "plus" | "mul", value: string | number): MyNumber;
+    subtract(value: MyNumber): MyNumber;
+    static min(a: MyNumber, b: MyNumber): MyNumber;
+    static max(a: MyNumber, b: MyNumber): MyNumber;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+}
+
 declare enum RiskType {
     MARKET_RISK = "Market Risk",
     IMPERMANENT_LOSS = "Impermanent Loss Risk",
@@ -96,17 +123,14 @@ interface IProtocol {
     name: string;
     logo: string;
 }
-declare enum StrategyCategory {
-    ALL = "all",
-    BTC = "btc",
-    META_VAULTS = "meta-vaults"
-}
 declare enum StrategyTag {
-    EKUBO = "Ekubo",
-    EVERGREEN = "Evergreen",
-    HYPER_LST = "Hyper-LST",
-    VESU = "Vesu",
-    SENSEI = "Sensei"
+    META_VAULT = "Meta Vaults",
+    LEVERED = "Maxx",
+    AUTOMATED_LP = "Ekubo",
+    BTC = "BTC"
+}
+declare enum VaultType {
+    FARMING = "farming"
 }
 declare enum AuditStatus {
     AUDITED = "Audited",
@@ -156,6 +180,35 @@ interface FAQ {
     question: string | React.ReactNode;
     answer: string | React.ReactNode;
 }
+declare enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    DEPRECATED = "Deprecated",// active but not recommended
+    RETIRED = "Retired",// not active anymore
+    HOT = "Hot & New \uD83D\uDD25"
+}
+interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+interface StrategySettings {
+    maxTVL?: Web3Number;
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
+}
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
@@ -163,15 +216,19 @@ interface FAQ {
  * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 interface IStrategyMetadata<T> {
+    id: string;
     name: string;
     description: string | React.ReactNode;
     address: ContractAddr;
     launchBlock: number;
     type: "ERC4626" | "ERC721" | "Other";
+    vaultType: {
+        type: VaultType;
+        description: string;
+    };
     depositTokens: TokenInfo[];
     protocols: IProtocol[];
     auditUrl?: string;
-    maxTVL: Web3Number;
     risk: {
         riskFactor: RiskFactor[];
         netRisk: number;
@@ -197,10 +254,29 @@ interface IStrategyMetadata<T> {
         logo: string;
     };
     isPreview?: boolean;
-    category: StrategyCategory;
     tags?: StrategyTag[];
     security: SecurityMetadata;
     redemptionInfo: RedemptionInfo;
+    settings?: StrategySettings;
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: {
+                name: string;
+                logo: string;
+            };
+            pool?: {
+                name: string;
+                logos?: string[];
+            };
+            apr?: number;
+            borrow?: {
+                apr?: number;
+            };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
 }
 interface IInvestmentFlow {
     id?: string;
@@ -213,6 +289,8 @@ interface IInvestmentFlow {
     style?: any;
 }
 declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
+declare const getStrategyTagDesciption: (tag: StrategyTag) => string;
+declare const getAllStrategyTags: () => StrategyTag[];
 declare const getRiskExplaination: (riskType: RiskType) => "The risk of the market moving against the position." | "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them." | "The risk of losing funds due to the position being liquidated." | "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position." | "The risk of the oracle being manipulated or incorrect." | "The risk of the smart contract being vulnerable to attacks." | "The risk of technical issues e.g. backend failure." | "The risk of the counterparty defaulting e.g. bad debt on lending platforms." | "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
 declare const getRiskColor: (risk: RiskFactor) => "light_green_2" | "yellow" | "red";
 declare const getNoRiskTags: (risks: RiskFactor[]) => RiskType[];
@@ -227,6 +305,27 @@ interface VaultPosition {
     token: TokenInfo;
     remarks: string;
 }
+interface AmountInfo {
+    amount: Web3Number;
+    usdValue: number;
+    tokenInfo: TokenInfo;
+}
+interface AmountsInfo {
+    usdValue: number;
+    amounts: AmountInfo[];
+}
+/**
+ * Strategy capabilities interface
+ * Describes what optional methods a strategy instance supports
+ */
+interface StrategyCapabilities {
+    hasMatchInputAmounts: boolean;
+    hasNetAPY: boolean;
+    hasGetInvestmentFlows: boolean;
+    hasGetPendingRewards: boolean;
+    hasHarvest: boolean;
+    hasRebalance: boolean;
+}
 declare const Protocols: {
     VESU: IProtocol;
     ENDUR: IProtocol;
@@ -303,7 +402,7 @@ declare class Pricer extends PricerBase {
     refreshInterval: number;
     staleTime: number;
     protected methodToUse: {
-        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap';
+        [tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu';
     };
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
@@ -321,6 +420,7 @@ 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>;
 }
 
@@ -485,6 +585,14 @@ interface DualTokenInfo {
     token0: SingleTokenInfo;
     token1: SingleTokenInfo;
 }
+interface NetAPYSplit {
+    apy: number;
+    id: string;
+}
+interface NetAPYDetails {
+    net: number;
+    splits: NetAPYSplit[];
+}
 interface CacheData {
     timestamp: number;
     ttl: number;
@@ -499,7 +607,9 @@ declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
     withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
     getVaultPositions(): Promise<VaultPosition[]>;
+    netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | NetAPYDetails>;
     getPendingRewards(): Promise<HarvestInfo[]>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
 }
 
 interface PoolProps {
@@ -856,7 +966,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
             usdValue: number;
         };
     }>;
-    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
     assertValidBounds(bounds: EkuboBounds): void;
     assertValidAmounts(expectedAmounts: any, token0Bal: Web3Number, token1Bal: Web3Number): void;
     getSwapParams(expectedAmounts: any, poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number): {
@@ -876,7 +986,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns {Promise<SwapInfo>}
      *
      */
-    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
     /**
      * Attempts to rebalance the vault by iteratively adjusting swap amounts if initial attempt fails.
      * Uses binary search approach to find optimal swap amount.
@@ -887,10 +997,16 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number, sameErrorCount?: {
+        count: number;
+        error: null | string;
+    }, MAX_SAME_ERROR_COUNT?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;
@@ -985,11 +1101,13 @@ declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmou
     }>;
     getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
     getSettings: () => Promise<starknet.CallResult>;
+    netAPY(): Promise<number>;
     /**
      * Calculates user realized APY based on position growth accounting for deposits and withdrawals.
      * Returns the APY as a number.
+     * Not implemented for Sensei Strategy yet.
      */
-    getUserRealizedAPY(userAddress: ContractAddr, blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
 }
 declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
 
@@ -1026,6 +1144,24 @@ declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
     dump(): StandardMerkleTreeData<LeafData>;
 }
 
+/**
+ * Convert SDK TVL info (SingleTokenInfo or DualTokenInfo) to client AmountsInfo format
+ */
+declare function toAmountsInfo(tvlInfo: SingleTokenInfo | DualTokenInfo): Omit<AmountsInfo, "amounts"> & {
+    amounts: Array<{
+        amount: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+};
+/**
+ * Detect what capabilities a strategy instance has
+ */
+declare function detectCapabilities(strategy: BaseStrategy<any, any>): StrategyCapabilities;
+/**
+ * Check if a strategy is a dual-token strategy
+ */
+declare function isDualTokenStrategy(strategy: BaseStrategy<any, any>): boolean;
+
 type RequiredFields<T> = {
     [K in keyof T]-?: T[K];
 };
@@ -1227,6 +1363,7 @@ declare const VesuPools: {
     Genesis: ContractAddr;
     Re7xSTRK: ContractAddr;
     Re7xBTC: ContractAddr;
+    Prime: ContractAddr;
 };
 declare const extensionMap: {
     [key: string]: ContractAddr;
@@ -1281,7 +1418,11 @@ declare class VesuAdapter extends BaseAdapter {
     };
     getDebtCap(config: IConfig): Promise<Web3Number>;
     getCurrentDebtUtilisationAmount(config: IConfig): Promise<Web3Number>;
-    getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number): Promise<Web3Number>;
+    getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number): Promise<{
+        maxDebtToHave: Web3Number;
+        currentDebt: Web3Number;
+        totalSupply: Web3Number;
+    }>;
     getLTVConfig(config: IConfig, blockNumber?: BlockIdentifier): Promise<number>;
     getPositions(config: IConfig, blockNumber?: BlockIdentifier): Promise<VaultPosition[]>;
     getCollateralization(config: IConfig, blockNumber?: BlockIdentifier): Promise<Omit<VaultPosition, 'amount'>[]>;
@@ -1332,6 +1473,7 @@ interface UniversalStrategySettings {
     vaultAllocator: ContractAddr;
     redeemRequestNFT: ContractAddr;
     aumOracle: ContractAddr;
+    redemptionRouter?: ContractAddr;
     leafAdapters: LeafAdapterFn<any>[];
     adapters: {
         id: string;
@@ -1497,13 +1639,15 @@ declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[
 interface HyperLSTStrategySettings extends UniversalStrategySettings {
     borrowable_assets: TokenInfo[];
     underlyingToken: TokenInfo;
+    defaultPoolId: ContractAddr;
+    altSupportedPoolIds: ContractAddr[];
 }
 declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
     private quoteAmountToFetchPrice;
     constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>);
     asset(): TokenInfo;
     getTag(): string;
-    getVesuSameTokenAdapter(): VesuAdapter;
+    getVesuSameTokenAdapter(poolId: ContractAddr): VesuAdapter;
     getVesuAdapters(): VesuAdapter[];
     protected getRewardsAUM(prevAum: Web3Number): Promise<Web3Number>;
     getLSTDexPrice(): Promise<number>;
@@ -1543,6 +1687,7 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
         isDeposit: boolean;
         leg1DepositAmount: Web3Number;
         maxEkuboPriceImpact?: number;
+        poolId: ContractAddr;
     }): Promise<Call[]>;
     getLSTUnderlyingTokenInfo(): TokenInfo;
     getMaxBorrowableAmount(params?: {
@@ -1554,6 +1699,7 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
             dexSwappableAmount: Web3Number;
             maxBorrowableAmount: Web3Number;
             borrowableAsset: TokenInfo;
+            ltv: number;
         }[];
     }>;
     getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number): Promise<Web3Number>;
@@ -1593,15 +1739,11 @@ declare class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTS
         lstDexPriceInUnderlying: number;
         isIncrease: boolean;
         maxEkuboPriceImpact: number;
+        poolId: ContractAddr;
     }): Promise<Call[]>;
 }
 declare const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[];
 
-/**
- * Strategy Registry - Centralized strategy metadata and filtering
- * Provides utilities for getting strategy lists, metadata, and filter options
- */
-
 /**
  * Filter option definition
  */
@@ -1616,7 +1758,6 @@ interface FilterOption {
 interface StrategyFilterMetadata {
     assets: FilterOption[];
     protocols: FilterOption[];
-    categories: FilterOption[];
     quickFilters: FilterOption[];
 }
 /**
@@ -1638,7 +1779,6 @@ interface StrategyMetadata {
     type: StrategyType;
     assets: string[];
     protocols: string[];
-    category: string;
     tags: string[];
     curator?: {
         name: string;
@@ -1673,16 +1813,27 @@ declare function getLiveStrategies(): StrategyRegistryEntry[];
  * Get strategies by type
  */
 declare function getStrategiesByType(type: StrategyType): StrategyRegistryEntry[];
+
+declare enum FactoryStrategyType {
+    UNIVERSAL = "UNIVERSAL",
+    EKUBO_CL = "EKUBO_CL",
+    HYPER_LST = "HYPER_LST",
+    VESU_REBALANCE = "VESU_REBALANCE",
+    SENSEI = "SENSEI"
+}
+declare function createUniversalStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>): UniversalStrategy<UniversalStrategySettings>;
+declare function createEkuboCLStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<CLVaultStrategySettings>): EkuboCLVault;
+declare function createHyperLSTStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>): UniversalLstMultiplierStrategy;
+declare function createVesuRebalanceStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<VesuRebalanceSettings>): VesuRebalance;
+declare function createSenseiStrategy(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<SenseiVaultSettings>): SenseiVault;
 /**
- * Get strategies by filter criteria
+ * Determines the strategy type from metadata by inspecting the additionalInfo structure
  */
-interface StrategyFilterCriteria {
-    assets?: string[];
-    protocols?: string[];
-    categories?: string[];
-    showRetired?: boolean;
-}
-declare function getFilteredStrategies(criteria: StrategyFilterCriteria): StrategyMetadata[];
+declare function getStrategyTypeFromMetadata(metadata: IStrategyMetadata<any>): FactoryStrategyType;
+/**
+ * Generic factory function that creates SDK strategy instances based on type
+ */
+declare function createStrategy(type: FactoryStrategyType, config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<any>): VesuRebalance | EkuboCLVault | SenseiVault | UniversalStrategy<UniversalStrategySettings>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -1726,16 +1877,6 @@ declare class EkuboQuoter {
     getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[];
 }
 
-declare class EkuboPricer extends PricerBase {
-    EKUBO_PRICE_FETCHER_ADDRESS: string;
-    readonly contract: Contract;
-    private readonly USDC_ADDRESS;
-    private readonly USDC_DECIMALS;
-    constructor(config: IConfig, tokens: TokenInfo[]);
-    private div2Power128;
-    getPrice(tokenAddr: string, blockIdentifier?: BlockIdentifier): Promise<PriceInfo>;
-}
-
 declare class FatalError extends Error {
     constructor(message: string, err?: Error);
 }
@@ -1754,6 +1895,7 @@ declare class Global {
     static getTokens(): Promise<TokenInfo[]>;
     static assert(condition: any, message: string): void;
     static getTokenInfoFromAddr(addr: ContractAddr): Promise<TokenInfo>;
+    static getTokenInfoFromName(tokenName: string): Promise<TokenInfo>;
     static setGlobalCache(key: string, data: any, ttl?: number): void;
     static getGlobalCache<T>(key: string): T | null;
 }
@@ -1967,4 +2109,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, EkuboPricer, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, InstantWithdrawalVault, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionExpectedTime, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, StrategyCategory, type StrategyFilterCriteria, type StrategyFilterMetadata, type StrategyMetadata, type StrategyRegistryEntry, StrategyTag, StrategyType, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, buildStrategyRegistry, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getContractDetails, getDefaultStoreConfig, getFilterMetadata, getFilteredStrategies, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, toBigInt };
+export { APYType, AUMTypes, AVNU_EXCHANGE, AVNU_MIDDLEWARE, type AccessControlInfo, AccessControlType, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type AmountInfo, type AmountsInfo, type ApproveCallParams, AuditStatus, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FactoryStrategyType, FatalError, type FilterOption, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, InstantWithdrawalVault, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, MyNumber, type NetAPYDetails, type NetAPYSplit, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, type PositionAPY, type PositionInfo, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RedemptionExpectedTime, type RedemptionInfo, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, type SecurityMetadata, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, type SourceCodeInfo, SourceCodeType, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type StrategyAlert, type StrategyCapabilities, type StrategyFilterMetadata, StrategyLiveStatus, type StrategyMetadata, type StrategyRegistryEntry, type StrategySettings, StrategyTag, StrategyType, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VaultType, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, buildStrategyRegistry, createEkuboCLStrategy, createHyperLSTStrategy, createSenseiStrategy, createStrategy, createUniversalStrategy, createVesuRebalanceStrategy, detectCapabilities, extensionMap, getAPIUsingHeadlessBrowser, getAllStrategyMetadata, getAllStrategyTags, getContractDetails, getDefaultStoreConfig, getFilterMetadata, getLiveStrategies, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getStrategiesByType, getStrategyTagDesciption, getStrategyTypeFromMetadata, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, isDualTokenStrategy, logger, toAmountsInfo, toBigInt };