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

package/src/strategies/vesu-rebalance.tsx

@@ -1,18 +1,33 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import {
-  FAQ,
-  FlowChartColors,
-  getNoRiskTags,
-  highlightTextWithLinks,
-  IConfig,
-  IInvestmentFlow,
-  IProtocol,
-  IStrategyMetadata,
-  RiskFactor,
-  RiskType
+    FAQ,
+    FlowChartColors,
+    getNoRiskTags,
+    highlightTextWithLinks,
+    IConfig,
+    IInvestmentFlow,
+    IProtocol,
+    IStrategyMetadata,
+    RiskFactor,
+    RiskType,
+    StrategyCategory,
+    StrategyTag,
+    StrategyLiveStatus,
+    StrategySettings,
+    AuditStatus,
+    SourceCodeType,
+    AccessControlType,
+    InstantWithdrawalVault
 } from "@/interfaces";
 import { AvnuWrapper, Pricer, SwapInfo } from "@/modules";
-import { Account, CairoCustomEnum, Contract, num, uint256 } from "starknet";
+import {
+    Account,
+    CairoCustomEnum,
+    Contract,
+    num,
+    uint256,
+    BlockIdentifier
+} from "starknet";
 import VesuRebalanceAbi from "@/data/vesu-rebalance.abi.json";
 import { Global } from "@/global";
 import { assert } from "@/utils";
@@ -20,48 +35,47 @@ import { logger } from "@/utils/logger";
 import axios from "axios";
 import { PricerBase } from "@/modules/pricerBase";
 import {
-  APYInfo,
-  BaseStrategy,
-  SingleActionAmount,
-  SingleTokenInfo
+    BaseStrategy,
+    SingleActionAmount,
+    SingleTokenInfo
 } from "./base-strategy";
 import { getAPIUsingHeadlessBrowser } from "@/node/headless";
-import { VESU_REWARDS_ENDPOINT, VesuHarvests } from "@/modules/harvests";
+import { HarvestInfo, VesuHarvests } from "@/modules/harvests";
 import VesuPoolIDs from "@/data/vesu_pools.json";
 import { COMMON_CONTRACTS, ENDPOINTS } from "./constants";
 
 interface PoolProps {
-  pool_id: ContractAddr;
-  max_weight: number;
-  v_token: ContractAddr;
+    pool_id: ContractAddr;
+    max_weight: number;
+    v_token: ContractAddr;
 }
 
 interface Change {
-  pool_id: ContractAddr;
-  changeAmt: Web3Number;
-  finalAmt: Web3Number;
-  isDeposit: boolean;
+    pool_id: ContractAddr;
+    changeAmt: Web3Number;
+    finalAmt: Web3Number;
+    isDeposit: boolean;
 }
 
 export interface VesuRebalanceSettings {
-  feeBps: number;
+    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;
+    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.
@@ -69,336 +83,510 @@ interface PoolInfoFull {
  * managing deposits and withdrawals while optimizing yield through STRK rewards.
  */
 export class VesuRebalance extends BaseStrategy<
-  SingleTokenInfo,
-  SingleActionAmount
+    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; // 10000 bps = 100%
-
-  /**
-   * 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>
-  ) {
-    super(config);
-    this.pricer = pricer;
-
-    assert(
-      metadata.depositTokens.length === 1,
-      "VesuRebalance only supports 1 deposit token"
-    );
-    this.metadata = metadata;
-    this.address = metadata.address;
-
-    this.contract = new Contract({
-      abi: VesuRebalanceAbi,
-      address: this.address.address,
-      providerOrAccount: this.config.provider
-    });
-  }
-
-  /**
-   * 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
-   */
-  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr) {
-    // Technically its not erc4626 abi, but we just need approve call
-    // so, its ok to use it
-    assert(
-      amountInfo.tokenInfo.address.eq(this.asset().address),
-      "Deposit token mismatch"
-    );
-    const assetContract = new Contract({
-      abi: VesuRebalanceAbi,
-      address: this.asset().address.address,
-      providerOrAccount: this.config.provider
-    });
-    const call1 = assetContract.populate("approve", [
-      this.address.address,
-      uint256.bnToUint256(amountInfo.amount.toWei())
-    ]);
-    const call2 = this.contract.populate("deposit", [
-      uint256.bnToUint256(amountInfo.amount.toWei()),
-      receiver.address
-    ]);
-    return [call1, call2];
-  }
-
-  /**
-   * 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
-   */
-  async withdrawCall(
-    amountInfo: SingleActionAmount,
-    receiver: ContractAddr,
-    owner: ContractAddr
-  ) {
-    return [
-      this.contract.populate("withdraw", [
-        uint256.bnToUint256(amountInfo.amount.toWei()),
-        receiver.address,
-        owner.address
-      ])
-    ];
-  }
-
-  /**
-   * Returns the underlying asset token of the strategy.
-   * @returns The deposit token supported by this strategy
-   */
-  asset() {
-    return this.metadata.depositTokens[0];
-  }
-
-  /**
-   * Returns the number of decimals used by the strategy token.
-   * @returns Number of decimals (same as the underlying token)
-   */
-  decimals() {
-    return this.metadata.depositTokens[0].decimals; // same as underlying token
-  }
-
-  /**
-   * 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
-   */
-  async getUserTVL(user: ContractAddr) {
-    const shares = await this.contract.balance_of(user.address);
-    const assets = await this.contract.convert_to_assets(
-      uint256.bnToUint256(shares)
-    );
-    const amount = Web3Number.fromWei(
-      assets.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    let price = await this.pricer.getPrice(
-      this.metadata.depositTokens[0].symbol
-    );
-    const usdValue = Number(amount.toFixed(6)) * price.price;
-    return {
-      tokenInfo: this.asset(),
-      amount,
-      usdValue
-    };
-  }
-
-  /**
-   * Calculates the total TVL of the strategy.
-   * @returns Object containing the total amount in token units and USD value
-   */
-  async getTVL() {
-    const assets = await this.contract.total_assets();
-    const amount = Web3Number.fromWei(
-      assets.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    let price = await this.pricer.getPrice(
-      this.metadata.depositTokens[0].symbol
-    );
-    const usdValue = Number(amount.toFixed(6)) * price.price;
-    return {
-      tokenInfo: this.asset(),
-      amount,
-      usdValue
-    };
-  }
-
-  static async getAllPossibleVerifiedPools(asset: ContractAddr) {
-    const data = await getAPIUsingHeadlessBrowser(`${ENDPOINTS.VESU_BASE_STAGING}/pools`);
-    const verifiedPools = data.data.filter((d: any) => d.isVerified);
-    const pools = verifiedPools
-      .map((p: any) => {
-        const hasMyAsset = p.assets.find((a: any) => asset.eqString(a.address));
-        if (hasMyAsset) {
-          return {
-            pool_id: ContractAddr.from(p.id),
-            max_weight: 10000,
-            v_token: ContractAddr.from(hasMyAsset.vToken.address),
-            name: p.name
-          };
-        }
-        return null;
-      })
-      .filter((p: PoolProps | null) => p !== null);
-    return pools;
-  }
-
-  async getPoolInfo(
-    p: PoolProps,
-    pools: any[],
-    vesuPositions: any[],
-    totalAssets: Web3Number,
-    isErrorPositionsAPI: boolean,
-    isErrorPoolsAPI: boolean
-  ) {
-    const vesuPosition = vesuPositions.find(
-      (d: any) =>
-        ContractAddr.from(d.id).eq(p.pool_id)
-    );
-    const _pool = pools.find((d: any) => {
-      logger.verbose(
-        `pool check: ${
-          ContractAddr.from(d.id).eq(p.pool_id)
-        }, id: ${d.id}, pool_id: ${num.getDecimalString(
-          p.pool_id.address.toString()
-        )}`
-      );
-      return ContractAddr.from(d.id).eq(p.pool_id);
-    });
-    logger.verbose(`pool: ${JSON.stringify(_pool)}`);
-    logger.verbose(typeof _pool);
-    logger.verbose(`name: ${_pool?.name}`);
-    const name = _pool?.name;
-    logger.verbose(
-      `name2: ${name}, ${!name ? true : false}, ${name?.length}, ${typeof name}`
-    );
-    const assetInfo = _pool?.assets.find((d: any) =>
-      this.asset().address.eqString(d.address)
-    );
-    if (!name) {
-      logger.verbose(`Pool not found`);
-      throw new Error(`Pool name ${p.pool_id.address.toString()} not found`);
+    /** 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; // 10000 bps = 100%
+
+    /**
+     * 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>
+    ) {
+        super(config);
+        this.pricer = pricer;
+
+        assert(
+            metadata.depositTokens.length === 1,
+            "VesuRebalance only supports 1 deposit token"
+        );
+        this.metadata = metadata;
+        this.address = metadata.address;
+
+        this.contract = new Contract({
+            abi: VesuRebalanceAbi,
+            address: this.address.address,
+            providerOrAccount: this.config.provider
+        });
     }
-    if (!assetInfo) {
-      throw new Error(
-        `Asset ${this.asset().address.toString()} not found in pool ${p.pool_id.address.toString()}`
-      );
+
+    /**
+     * 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
+     */
+    async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr) {
+        // Technically its not erc4626 abi, but we just need approve call
+        // so, its ok to use it
+        assert(
+            amountInfo.tokenInfo.address.eq(this.asset().address),
+            "Deposit token mismatch"
+        );
+        const assetContract = new Contract({
+            abi: VesuRebalanceAbi,
+            address: this.asset().address.address,
+            providerOrAccount: this.config.provider
+        });
+        const call1 = assetContract.populate("approve", [
+            this.address.address,
+            uint256.bnToUint256(amountInfo.amount.toWei())
+        ]);
+        const call2 = this.contract.populate("deposit", [
+            uint256.bnToUint256(amountInfo.amount.toWei()),
+            receiver.address
+        ]);
+        return [call1, call2];
     }
-    let vTokenContract = new Contract({
-      abi: VesuRebalanceAbi,
-      address: p.v_token.address,
-      providerOrAccount: this.config.provider
-    });
-    const bal = await vTokenContract.balance_of(this.address.address);
-    const assets = await vTokenContract.convert_to_assets(
-      uint256.bnToUint256(bal.toString())
-    );
-    logger.verbose(`Collateral: ${JSON.stringify(vesuPosition?.collateral)}`);
-    logger.verbose(`supplyApy: ${JSON.stringify(assetInfo?.stats.supplyApy)}`);
-    logger.verbose(
-      `defiSpringSupplyApr: ${JSON.stringify(
-        assetInfo?.stats.defiSpringSupplyApr
-      )}`
-    );
-    logger.verbose(
-      `currentUtilization: ${JSON.stringify(
-        assetInfo?.stats.currentUtilization
-      )}`
-    );
-    logger.verbose(
-      `maxUtilization: ${JSON.stringify(assetInfo?.config.maxUtilization)}`
-    );
-    const item = {
-      pool_id: p.pool_id,
-      pool_name: _pool?.name,
-      max_weight: p.max_weight,
-      current_weight:
-        isErrorPositionsAPI || !vesuPosition
-          ? 0
-          : Number(
-              Web3Number.fromWei(vesuPosition.collateral.value, this.decimals())
-                .dividedBy(totalAssets.toString())
-                .toFixed(6)
-            ),
-      v_token: p.v_token,
-      amount: Web3Number.fromWei(assets.toString(), this.decimals()),
-      usdValue:
-        isErrorPositionsAPI || !vesuPosition
-          ? Web3Number.fromWei("0", this.decimals())
-          : Web3Number.fromWei(
-              vesuPosition.collateral.usdPrice.value,
-              vesuPosition.collateral.usdPrice.decimals
-            ),
-      APY:
-        isErrorPoolsAPI || !assetInfo
-          ? {
-              baseApy: 0,
-              defiSpringApy: 0,
-              netApy: 0
+
+    /**
+     * 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
+     */
+    async withdrawCall(
+        amountInfo: SingleActionAmount,
+        receiver: ContractAddr,
+        owner: ContractAddr
+    ) {
+        return [
+            this.contract.populate("withdraw", [
+                uint256.bnToUint256(amountInfo.amount.toWei()),
+                receiver.address,
+                owner.address
+            ])
+        ];
+    }
+
+    /**
+     * Returns the underlying asset token of the strategy.
+     * @returns The deposit token supported by this strategy
+     */
+    asset() {
+        return this.metadata.depositTokens[0];
+    }
+
+    /**
+     * Returns the number of decimals used by the strategy token.
+     * @returns Number of decimals (same as the underlying token)
+     */
+    decimals() {
+        return this.metadata.depositTokens[0].decimals; // same as underlying token
+    }
+
+    /**
+     * Calculates the Total Value Locked (TVL) for a specific user.
+     * @param user - Address of the user
+     * @param blockIdentifier - Block identifier for the query
+     * @returns Object containing the amount in token units and USD value
+     */
+    async getUserTVL(
+        user: ContractAddr,
+        blockIdentifier: BlockIdentifier = "latest"
+    ) {
+        const shares: any = await this.contract.call(
+            "balanceOf",
+            [user.address],
+            { blockIdentifier }
+        );
+        const assets: any = await this.contract.call(
+            "convert_to_assets",
+            [uint256.bnToUint256(shares)],
+            { blockIdentifier }
+        );
+        const amount = Web3Number.fromWei(
+            assets.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+
+        // Convert blockIdentifier to block number for pricer if it's a number
+        const blockNumber =
+            typeof blockIdentifier === "number" ||
+            typeof blockIdentifier === "bigint"
+                ? Number(blockIdentifier)
+                : undefined;
+
+        let price = await this.pricer.getPrice(
+            this.metadata.depositTokens[0].symbol,
+            blockNumber
+        );
+        const usdValue = Number(amount.toFixed(6)) * price.price;
+        return {
+            tokenInfo: this.asset(),
+            amount,
+            usdValue
+        };
+    }
+
+    /**
+     * Calculates user realized APY based on trueSharesBasedAPY method.
+     * Returns the APY as a number.
+     */
+    async getUserRealizedAPY(
+        blockIdentifier: BlockIdentifier = "latest",
+        sinceBlocks = 600000
+    ): Promise<number> {
+        logger.verbose(
+            `${VesuRebalance.name}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+        );
+
+        // Determine current block number and timestamp
+        let blockNow =
+            typeof blockIdentifier === "number" ||
+            typeof blockIdentifier === "bigint"
+                ? Number(blockIdentifier)
+                : (await this.config.provider.getBlockLatestAccepted())
+                      .block_number;
+        const blockNowTime =
+            typeof blockIdentifier === "number" ||
+            typeof blockIdentifier === "bigint"
+                ? (await this.config.provider.getBlockWithTxs(blockIdentifier))
+                      .timestamp
+                : new Date().getTime() / 1000;
+
+        // Look back window, but never before launch block
+        const blockBefore = Math.max(
+            blockNow - sinceBlocks,
+            this.metadata.launchBlock
+        );
+
+        // TVL amounts (in underlying token units) and supply at current reference block
+        const assetsNowRaw: bigint = (await this.contract.call(
+            "total_assets",
+            [],
+            {
+                blockIdentifier
             }
-          : {
-              baseApy: Number(
-                Web3Number.fromWei(
-                  assetInfo.stats.supplyApy.value,
-                  assetInfo.stats.supplyApy.decimals
-                ).toFixed(6)
-              ),
-              defiSpringApy: assetInfo.stats.defiSpringSupplyApr
-                ? Number(
-                    Web3Number.fromWei(
-                      assetInfo.stats.defiSpringSupplyApr.value,
-                      assetInfo.stats.defiSpringSupplyApr.decimals
-                    ).toFixed(6)
-                  )
-                : 0,
-              netApy: 0
-            },
-      currentUtilization:
-        isErrorPoolsAPI || !assetInfo
-          ? 0
-          : Number(
-              Web3Number.fromWei(
-                assetInfo.stats.currentUtilization.value,
-                assetInfo.stats.currentUtilization.decimals
-              ).toFixed(6)
-            ),
-      maxUtilization:
-        isErrorPoolsAPI || !assetInfo
-          ? 0
-          : Number(
-              Web3Number.fromWei(
-                assetInfo.config.maxUtilization.value,
-                assetInfo.config.maxUtilization.decimals
-              ).toFixed(6)
-            )
-    };
-    item.APY.netApy = item.APY.baseApy + item.APY.defiSpringApy;
-    return item;
-  }
-
-  /**
-   * 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
-   */
-  async getPools() {
-    const allowedPools: PoolProps[] = (
-      await this.contract.get_allowed_pools()
-    ).map((p: any) => ({
-      pool_id: ContractAddr.from(p.pool_id),
-      max_weight: Number(p.max_weight) / this.BASE_WEIGHT,
-      v_token: ContractAddr.from(p.v_token)
-    }));
-
-    /*
+        )) as bigint;
+        const amountNow = Web3Number.fromWei(
+            assetsNowRaw.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+
+        const supplyNowRaw: bigint = (await this.contract.call(
+            "total_supply",
+            [],
+            {
+                blockIdentifier
+            }
+        )) as bigint;
+        const supplyNow = Web3Number.fromWei(
+            supplyNowRaw.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+
+        // Historical TVL and supply
+        const assetsBeforeRaw: bigint = (await this.contract.call(
+            "total_assets",
+            [],
+            { blockIdentifier: blockBefore }
+        )) as bigint;
+        const amountBefore = Web3Number.fromWei(
+            assetsBeforeRaw.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+
+        const supplyBeforeRaw: bigint = (await this.contract.call(
+            "total_supply",
+            [],
+            { blockIdentifier: blockBefore }
+        )) as bigint;
+        const supplyBefore = Web3Number.fromWei(
+            supplyBeforeRaw.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+
+        const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+            blockBefore
+        );
+
+        const assetsPerShareNow = amountNow
+            .multipliedBy(1e18)
+            .dividedBy(supplyNow.toString());
+
+        const assetsPerShareBf = amountBefore
+            .multipliedBy(1e18)
+            .dividedBy(supplyBefore.toString());
+
+        const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${
+                this.metadata.name
+            } [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`
+        );
+        logger.verbose(
+            `${VesuRebalance.name}:${this.metadata.name} [getUserRealizedAPY] Time diff in seconds: ${timeDiffSeconds}`
+        );
+
+        const apyForGivenBlocks =
+            Number(
+                assetsPerShareNow
+                    .minus(assetsPerShareBf)
+                    .multipliedBy(10000)
+                    .dividedBy(assetsPerShareBf)
+            ) / 10000;
+
+        return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
+    }
+
+    /**
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
+     */
+    async getTVL(): Promise<SingleTokenInfo> {
+        const assets = await this.contract.total_assets();
+        const amount = Web3Number.fromWei(
+            assets.toString(),
+            this.metadata.depositTokens[0].decimals
+        );
+        let price = await this.pricer.getPrice(
+            this.metadata.depositTokens[0].symbol
+        );
+        const usdValue = Number(amount.toFixed(6)) * price.price;
+        return {
+            tokenInfo: this.asset(),
+            amount,
+            usdValue
+        };
+    }
+
+    static async getAllPossibleVerifiedPools(asset: ContractAddr) {
+        const data = await getAPIUsingHeadlessBrowser(
+            `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+        );
+        const verifiedPools = data.data.filter((d: any) => d.isVerified);
+        const pools = verifiedPools
+            .map((p: any) => {
+                const hasMyAsset = p.assets.find((a: any) =>
+                    asset.eqString(a.address)
+                );
+                if (hasMyAsset) {
+                    return {
+                        pool_id: ContractAddr.from(p.id),
+                        max_weight: 10000,
+                        v_token: ContractAddr.from(hasMyAsset.vToken.address),
+                        name: p.name
+                    };
+                }
+                return null;
+            })
+            .filter((p: PoolProps | null) => p !== null);
+        return pools;
+    }
+
+    async getPoolInfo(
+        p: PoolProps,
+        pools: any[],
+        vesuPositions: any[],
+        totalAssets: Web3Number,
+        isErrorPositionsAPI: boolean,
+        isErrorPoolsAPI: boolean
+    ) {
+        const vesuPosition = vesuPositions.find((d: any) =>
+            ContractAddr.from(d.id).eq(p.pool_id)
+        );
+        const _pool = pools.find((d: any) => {
+            logger.verbose(
+                `pool check: ${ContractAddr.from(d.id).eq(p.pool_id)}, id: ${
+                    d.id
+                }, pool_id: ${num.getDecimalString(
+                    p.pool_id.address.toString()
+                )}`
+            );
+            return ContractAddr.from(d.id).eq(p.pool_id);
+        });
+        logger.verbose(`pool: ${JSON.stringify(_pool)}`);
+        logger.verbose(typeof _pool);
+        logger.verbose(`name: ${_pool?.name}`);
+        const name = _pool?.name;
+        logger.verbose(
+            `name2: ${name}, ${!name ? true : false}, ${
+                name?.length
+            }, ${typeof name}`
+        );
+        const assetInfo = _pool?.assets.find((d: any) =>
+            this.asset().address.eqString(d.address)
+        );
+        if (!name) {
+            logger.verbose(`Pool not found`);
+            throw new Error(
+                `Pool name ${p.pool_id.address.toString()} not found`
+            );
+        }
+        if (!assetInfo) {
+            throw new Error(
+                `Asset ${this.asset().address.toString()} not found in pool ${p.pool_id.address.toString()}`
+            );
+        }
+        let vTokenContract = new Contract({
+            abi: VesuRebalanceAbi,
+            address: p.v_token.address,
+            providerOrAccount: this.config.provider
+        });
+        const bal = await vTokenContract.balanceOf(this.address.address);
+        const assets = await vTokenContract.convert_to_assets(
+            uint256.bnToUint256(bal.toString())
+        );
+        logger.verbose(
+            `Collateral: ${JSON.stringify(vesuPosition?.collateral)}`
+        );
+        logger.verbose(
+            `supplyApy: ${JSON.stringify(assetInfo?.stats.supplyApy)}`
+        );
+        logger.verbose(
+            `defiSpringSupplyApr: ${JSON.stringify(
+                assetInfo?.stats.defiSpringSupplyApr
+            )}`
+        );
+        logger.verbose(
+            `currentUtilization: ${JSON.stringify(
+                assetInfo?.stats.currentUtilization
+            )}`
+        );
+        logger.verbose(
+            `maxUtilization: ${JSON.stringify(
+                assetInfo?.config.maxUtilization
+            )}`
+        );
+        const item = {
+            pool_id: p.pool_id,
+            pool_name: _pool?.name,
+            max_weight: p.max_weight,
+            current_weight:
+                isErrorPositionsAPI || !vesuPosition
+                    ? 0
+                    : Number(
+                          Web3Number.fromWei(
+                              vesuPosition.collateral.value,
+                              this.decimals()
+                          )
+                              .dividedBy(totalAssets.toString())
+                              .toFixed(6)
+                      ),
+            v_token: p.v_token,
+            amount: Web3Number.fromWei(assets.toString(), this.decimals()),
+            usdValue:
+                isErrorPositionsAPI || !vesuPosition
+                    ? Web3Number.fromWei("0", this.decimals())
+                    : Web3Number.fromWei(
+                          vesuPosition.collateral.usdPrice.value,
+                          vesuPosition.collateral.usdPrice.decimals
+                      ),
+            APY:
+                isErrorPoolsAPI || !assetInfo
+                    ? {
+                          baseApy: 0,
+                          defiSpringApy: 0,
+                          netApy: 0
+                      }
+                    : {
+                          baseApy: Number(
+                              Web3Number.fromWei(
+                                  assetInfo.stats.supplyApy.value,
+                                  assetInfo.stats.supplyApy.decimals
+                              ).toFixed(6)
+                          ),
+                          defiSpringApy: assetInfo.stats.defiSpringSupplyApr
+                              ? Number(
+                                    Web3Number.fromWei(
+                                        assetInfo.stats.defiSpringSupplyApr
+                                            .value,
+                                        assetInfo.stats.defiSpringSupplyApr
+                                            .decimals
+                                    ).toFixed(6)
+                                )
+                              : 0,
+                          netApy: 0
+                      },
+            currentUtilization:
+                isErrorPoolsAPI || !assetInfo
+                    ? 0
+                    : Number(
+                          Web3Number.fromWei(
+                              assetInfo.stats.currentUtilization.value,
+                              assetInfo.stats.currentUtilization.decimals
+                          ).toFixed(6)
+                      ),
+            maxUtilization:
+                isErrorPoolsAPI || !assetInfo
+                    ? 0
+                    : Number(
+                          Web3Number.fromWei(
+                              assetInfo.config.maxUtilization.value,
+                              assetInfo.config.maxUtilization.decimals
+                          ).toFixed(6)
+                      )
+        };
+        item.APY.netApy = item.APY.baseApy + item.APY.defiSpringApy;
+        return item;
+    }
+
+    /**
+     * 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
+     */
+    async getPools() {
+        const allowedPools: PoolProps[] = (
+            await this.contract.get_allowed_pools()
+        ).map((p: any) => ({
+            pool_id: ContractAddr.from(p.pool_id),
+            max_weight: Number(p.max_weight) / this.BASE_WEIGHT,
+            v_token: ContractAddr.from(p.v_token)
+        }));
+
+        /*
             Vesu Positions API Response Schema (/positions?walletAddress=):
             {
               "data": [{
@@ -445,674 +633,689 @@ export class VesuRebalance extends BaseStrategy<
               }]
             }
         */
-    let isErrorPositionsAPI = false;
-    let vesuPositions: any[] = [];
-    try {
-      const data = await getAPIUsingHeadlessBrowser(
-        `https://staging.api.vesu.xyz/positions?walletAddress=${this.address.address}`
-      );
-      vesuPositions = data.data;
-    } catch (e) {
-      console.error(
-        `${VesuRebalance.name}: Error fetching positions for ${this.address.address}`,
-        e
-      );
-      isErrorPositionsAPI = true;
-    }
+        let isErrorPositionsAPI = false;
+        let vesuPositions: any[] = [];
+        try {
+            const data = await getAPIUsingHeadlessBrowser(
+                `https://staging.api.vesu.xyz/positions?walletAddress=${this.address.address}`
+            );
+            vesuPositions = data.data;
+        } catch (e) {
+            console.error(
+                `${VesuRebalance.name}: Error fetching positions for ${this.address.address}`,
+                e
+            );
+            isErrorPositionsAPI = true;
+        }
 
-    let { pools, isErrorPoolsAPI } = await this.getVesuPools();
+        let { pools, isErrorPoolsAPI } = await this.getVesuPools();
 
-    const totalAssets = (await this.getTVL()).amount;
+        const totalAssets = (await this.getTVL()).amount;
 
-    const info = allowedPools.map((p) =>
-      this.getPoolInfo(
-        p,
-        pools,
-        vesuPositions,
-        totalAssets,
-        isErrorPositionsAPI,
-        isErrorPoolsAPI
-      )
-    );
-    const data = await Promise.all(info);
-    return {
-      data,
-      isErrorPositionsAPI,
-      isErrorPoolsAPI,
-      isError: isErrorPositionsAPI || isErrorPoolsAPI
-    };
-  }
-
-  async getVesuPools(
-    retry = 0
-  ): Promise<{ pools: any[]; isErrorPoolsAPI: boolean }> {
-    let isErrorPoolsAPI = false;
-    let pools: any[] = [];
-    try {
-      const data = await getAPIUsingHeadlessBrowser(
-        `${ENDPOINTS.VESU_BASE_STAGING}/pools`
-      );
-      pools = data.data;
-
-      // Vesu API is unstable sometimes, some Pools may be missing sometimes
-      for (const pool of VesuPoolIDs.data) {
-        const found = pools.find((d: any) => ContractAddr.from(d.id).eqString(pool.id));
-        if (!found) {
-          logger.verbose(`VesuRebalance: pools: ${JSON.stringify(pools)}`);
-          logger.verbose(
-            `VesuRebalance: Pool ${pool.id} not found in Vesu API, using hardcoded data`
-          );
-          throw new Error(`pool not found [sanity check]: ${pool.id}`);
+        const info = allowedPools.map((p) =>
+            this.getPoolInfo(
+                p,
+                pools,
+                vesuPositions,
+                totalAssets,
+                isErrorPositionsAPI,
+                isErrorPoolsAPI
+            )
+        );
+        const data = await Promise.all(info);
+        return {
+            data,
+            isErrorPositionsAPI,
+            isErrorPoolsAPI,
+            isError: isErrorPositionsAPI || isErrorPoolsAPI
+        };
+    }
+
+    async getVesuPools(
+        retry = 0
+    ): Promise<{ pools: any[]; isErrorPoolsAPI: boolean }> {
+        let isErrorPoolsAPI = false;
+        let pools: any[] = [];
+        try {
+            const data = await getAPIUsingHeadlessBrowser(
+                `${ENDPOINTS.VESU_BASE_STAGING}/pools`
+            );
+            pools = data.data;
+
+            // Vesu API is unstable sometimes, some Pools may be missing sometimes
+            for (const pool of VesuPoolIDs.data) {
+                const found = pools.find((d: any) =>
+                    ContractAddr.from(d.id).eqString(pool.id)
+                );
+                if (!found) {
+                    logger.verbose(
+                        `VesuRebalance: pools: ${JSON.stringify(pools)}`
+                    );
+                    logger.verbose(
+                        `VesuRebalance: Pool ${pool.id} not found in Vesu API, using hardcoded data`
+                    );
+                    throw new Error(
+                        `pool not found [sanity check]: ${pool.id}`
+                    );
+                }
+            }
+        } catch (e) {
+            logger.error(
+                `${VesuRebalance.name}: Error fetching pools for ${this.address.address}, retry ${retry}`,
+                e
+            );
+            isErrorPoolsAPI = true;
+            if (retry < 10) {
+                await new Promise((resolve) =>
+                    setTimeout(resolve, 5000 * (retry + 1))
+                );
+                return await this.getVesuPools(retry + 1);
+            }
         }
-      }
-    } catch (e) {
-      logger.error(
-        `${VesuRebalance.name}: Error fetching pools for ${this.address.address}, retry ${retry}`,
-        e
-      );
-      isErrorPoolsAPI = true;
-      if (retry < 10) {
-        await new Promise((resolve) => setTimeout(resolve, 5000 * (retry + 1)));
-        return await this.getVesuPools(retry + 1);
-      }
+
+        return { pools, isErrorPoolsAPI };
     }
 
-    return { pools, isErrorPoolsAPI };
-  }
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    async netAPY(): Promise<number> {
+        const { data: pools } = await this.getPools();
+        return this.netAPYGivenPools(pools);
+    }
 
-  /**
-   * Calculates the weighted average APY across all pools based on USD value.
-   * @returns {Promise<number>} The weighted average APY across all pools
-   */
-  async netAPY(): Promise<APYInfo > {
-    const { data: pools } = await this.getPools();
-    return {
-      net: await this.netAPYGivenPools(pools),
-      splits: []
-    };
-  }
-
-  /**
-   * Calculates the weighted average APY across all pools based on USD value.
-   * @returns {Promise<number>} The weighted average APY across all pools
-   */
-  async netAPYGivenPools(pools: PoolInfoFull[]): Promise<number> {
-    const weightedApyNumerator = pools.reduce((acc: number, curr) => {
-      const weight = curr.current_weight;
-      return acc + curr.APY.netApy * Number(curr.amount.toString());
-    }, 0);
-    const totalAssets = (await this.getTVL()).amount;
-    const weightedApy = weightedApyNumerator / Number(totalAssets.toString());
-    return weightedApy * (1 - this.metadata.additionalInfo.feeBps / 10000);
-  }
-
-  /**
-   * 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
-   */
-  async getRebalancedPositions(_pools?: PoolInfoFull[]) {
-    logger.verbose(`VesuRebalance: getRebalancedPositions`);
-    if (!_pools) {
-      const { data: _pools2 } = await this.getPools();
-      _pools = _pools2;
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    async netAPYGivenPools(pools: PoolInfoFull[]): Promise<number> {
+        const weightedApyNumerator = pools.reduce((acc: number, curr) => {
+            const weight = curr.current_weight;
+            return acc + curr.APY.netApy * Number(curr.amount.toString());
+        }, 0);
+        const totalAssets = (await this.getTVL()).amount;
+        const weightedApy =
+            weightedApyNumerator / Number(totalAssets.toString());
+        return weightedApy * (1 - this.metadata.additionalInfo.feeBps / 10000);
     }
-    const feeDeductions = await this.getFee(_pools);
-    logger.verbose(
-      `VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`
-    );
 
-    // remove fee from pools
-    const pools = _pools.map((p) => {
-      const fee =
-        feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee ||
-        Web3Number.fromWei("0", this.decimals());
-      logger.verbose(
-        `FeeAdjustment: ${
-          p.pool_id
-        } => ${fee.toString()}, amt: ${p.amount.toString()}`
-      );
-      return {
-        ...p,
-        amount: p.amount.minus(fee)
-      };
-    });
-    let totalAssets = (await this.getTVL()).amount;
-    if (totalAssets.eq(0))
-      return {
-        changes: [],
-        finalPools: []
-      };
-    // deduct fee from total assets
-    feeDeductions.forEach((f) => {
-      totalAssets = totalAssets.minus(f.fee);
-    });
-
-    // assert sum of pools.amount <= totalAssets
-    const sumPools = pools.reduce(
-      (acc, curr) => acc.plus(curr.amount.toString()),
-      Web3Number.fromWei("0", this.decimals())
-    );
-    logger.verbose(`Sum of pools: ${sumPools.toString()}`);
-    logger.verbose(`Total assets: ${totalAssets.toString()}`);
-    assert(
-      sumPools.lte(totalAssets.multipliedBy(1.00001).toString()),
-      "Sum of pools.amount must be less than or equal to totalAssets"
-    );
+    /**
+     * 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
+     */
+    async getRebalancedPositions(_pools?: PoolInfoFull[]) {
+        logger.verbose(`VesuRebalance: getRebalancedPositions`);
+        if (!_pools) {
+            const { data: _pools2 } = await this.getPools();
+            _pools = _pools2;
+        }
+        const feeDeductions = await this.getFee(_pools);
+        logger.verbose(
+            `VesuRebalance: feeDeductions: ${JSON.stringify(feeDeductions)}`
+        );
+
+        // remove fee from pools
+        const pools = _pools.map((p) => {
+            const fee =
+                feeDeductions.find((f) => p.v_token.eq(f.vToken))?.fee ||
+                Web3Number.fromWei("0", this.decimals());
+            logger.verbose(
+                `FeeAdjustment: ${
+                    p.pool_id
+                } => ${fee.toString()}, amt: ${p.amount.toString()}`
+            );
+            return {
+                ...p,
+                amount: p.amount.minus(fee)
+            };
+        });
+        let totalAssets = (await this.getTVL()).amount;
+        if (totalAssets.eq(0))
+            return {
+                changes: [],
+                finalPools: []
+            };
+        // deduct fee from total assets
+        feeDeductions.forEach((f) => {
+            totalAssets = totalAssets.minus(f.fee);
+        });
+
+        // assert sum of pools.amount <= totalAssets
+        const sumPools = pools.reduce(
+            (acc, curr) => acc.plus(curr.amount.toString()),
+            Web3Number.fromWei("0", this.decimals())
+        );
+        logger.verbose(`Sum of pools: ${sumPools.toString()}`);
+        logger.verbose(`Total assets: ${totalAssets.toString()}`);
+        assert(
+            sumPools.lte(totalAssets.multipliedBy(1.00001).toString()),
+            "Sum of pools.amount must be less than or equal to totalAssets"
+        );
+
+        // Sort pools by APY and calculate target amounts
+        const sortedPools = [...pools].sort(
+            (a, b) => b.APY.netApy - a.APY.netApy
+        );
+        const targetAmounts: Record<string, Web3Number> = {};
+        let remainingAssets = totalAssets;
+        logger.verbose(`Remaining assets: ${remainingAssets.toString()}`);
+
+        // First pass: Allocate to high APY pools up to their max weight
+        let isAnyPoolOverMaxWeight = false;
+        for (const pool of sortedPools) {
+            const maxAmount = totalAssets.multipliedBy(pool.max_weight * 0.98); // some tolerance
+            const targetAmount = remainingAssets.gte(maxAmount)
+                ? maxAmount
+                : remainingAssets;
+            logger.verbose(`Target amount: ${targetAmount.toString()}`);
+            logger.verbose(`Remaining assets: ${remainingAssets.toString()}`);
+            logger.verbose(`Max amount: ${maxAmount.toString()}`);
+            logger.verbose(`pool.max_weight: ${pool.max_weight}`);
+            targetAmounts[pool.pool_id.address.toString()] = targetAmount;
+            remainingAssets = remainingAssets.minus(targetAmount.toString());
+            if (pool.current_weight > pool.max_weight) {
+                isAnyPoolOverMaxWeight = true;
+            }
+        }
+
+        assert(remainingAssets.lt(0.00001), "Remaining assets must be 0");
+
+        // Calculate required changes
+        const changes: Change[] = sortedPools.map((pool) => {
+            const target =
+                targetAmounts[pool.pool_id.address.toString()] ||
+                Web3Number.fromWei("0", this.decimals());
+            const change = Web3Number.fromWei(
+                target.minus(pool.amount.toString()).toWei(),
+                this.decimals()
+            );
+            return {
+                pool_id: pool.pool_id,
+                changeAmt: change,
+                finalAmt: target,
+                isDeposit: change.gt(0)
+            };
+        });
+
+        logger.verbose(`Changes: ${JSON.stringify(changes)}`);
+        // Validate changes
+        const sumChanges = changes.reduce(
+            (sum, c) => sum.plus(c.changeAmt.toString()),
+            Web3Number.fromWei("0", this.decimals())
+        );
+        const sumFinal = changes.reduce(
+            (sum, c) => sum.plus(c.finalAmt.toString()),
+            Web3Number.fromWei("0", this.decimals())
+        );
+        const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
 
-    // Sort pools by APY and calculate target amounts
-    const sortedPools = [...pools].sort((a, b) => b.APY.netApy - a.APY.netApy);
-    const targetAmounts: Record<string, Web3Number> = {};
-    let remainingAssets = totalAssets;
-    logger.verbose(`Remaining assets: ${remainingAssets.toString()}`);
-
-    // First pass: Allocate to high APY pools up to their max weight
-    let isAnyPoolOverMaxWeight = false;
-    for (const pool of sortedPools) {
-      const maxAmount = totalAssets.multipliedBy(pool.max_weight * 0.98); // some tolerance
-      const targetAmount = remainingAssets.gte(maxAmount)
-        ? maxAmount
-        : remainingAssets;
-      logger.verbose(`Target amount: ${targetAmount.toString()}`);
-      logger.verbose(`Remaining assets: ${remainingAssets.toString()}`);
-      logger.verbose(`Max amount: ${maxAmount.toString()}`);
-      logger.verbose(`pool.max_weight: ${pool.max_weight}`);
-      targetAmounts[pool.pool_id.address.toString()] = targetAmount;
-      remainingAssets = remainingAssets.minus(targetAmount.toString());
-      if (pool.current_weight > pool.max_weight) {
-        isAnyPoolOverMaxWeight = true;
-      }
+        logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
+        if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
+        logger.verbose(`Sum of final: ${sumFinal.toString()}`);
+        logger.verbose(`Total assets: ${totalAssets.toString()}`);
+        if (!sumFinal.eq(totalAssets.toString()))
+            throw new Error("Sum of final amounts must equal total assets");
+        if (!hasChanges) throw new Error("No changes required");
+
+        const finalPools: PoolInfoFull[] = pools.map((p) => {
+            const target =
+                targetAmounts[p.pool_id.address.toString()] ||
+                Web3Number.fromWei("0", this.decimals());
+            return {
+                ...p,
+                amount: target,
+                usdValue: Web3Number.fromWei("0", this.decimals())
+            };
+        });
+        return {
+            changes,
+            finalPools,
+            isAnyPoolOverMaxWeight
+        };
     }
 
-    assert(remainingAssets.lt(0.00001), "Remaining assets must be 0");
-
-    // Calculate required changes
-    const changes: Change[] = sortedPools.map((pool) => {
-      const target =
-        targetAmounts[pool.pool_id.address.toString()] ||
-        Web3Number.fromWei("0", this.decimals());
-      const change = Web3Number.fromWei(
-        target.minus(pool.amount.toString()).toWei(),
-        this.decimals()
-      );
-      return {
-        pool_id: pool.pool_id,
-        changeAmt: change,
-        finalAmt: target,
-        isDeposit: change.gt(0)
-      };
-    });
-
-    logger.verbose(`Changes: ${JSON.stringify(changes)}`);
-    // Validate changes
-    const sumChanges = changes.reduce(
-      (sum, c) => sum.plus(c.changeAmt.toString()),
-      Web3Number.fromWei("0", this.decimals())
-    );
-    const sumFinal = changes.reduce(
-      (sum, c) => sum.plus(c.finalAmt.toString()),
-      Web3Number.fromWei("0", this.decimals())
-    );
-    const hasChanges = changes.some((c) => !c.changeAmt.eq(0));
-
-    logger.verbose(`Sum of changes: ${sumChanges.toString()}`);
-    if (!sumChanges.eq(0)) throw new Error("Sum of changes must be zero");
-    logger.verbose(`Sum of final: ${sumFinal.toString()}`);
-    logger.verbose(`Total assets: ${totalAssets.toString()}`);
-    if (!sumFinal.eq(totalAssets.toString()))
-      throw new Error("Sum of final amounts must equal total assets");
-    if (!hasChanges) throw new Error("No changes required");
-
-    const finalPools: PoolInfoFull[] = pools.map((p) => {
-      const target =
-        targetAmounts[p.pool_id.address.toString()] ||
-        Web3Number.fromWei("0", this.decimals());
-      return {
-        ...p,
-        amount: target,
-        usdValue: Web3Number.fromWei("0", this.decimals())
-      };
-    });
-    return {
-      changes,
-      finalPools,
-      isAnyPoolOverMaxWeight
-    };
-  }
-
-  /**
-   * 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
-   */
-  async getRebalanceCall(
-    pools: Awaited<ReturnType<typeof this.getRebalancedPositions>>["changes"],
-    isOverWeightAdjustment: boolean // here, yield increase doesnt matter
-  ) {
-    const actions: any[] = [];
-    // sort to put withdrawals first
-    pools.sort((a, b) => (b.isDeposit ? -1 : 1));
-    pools.forEach((p) => {
-      if (p.changeAmt.eq(0)) return null;
-      actions.push({
-        pool_id: p.pool_id.address,
-        feature: new CairoCustomEnum(
-          p.isDeposit ? { DEPOSIT: {} } : { WITHDRAW: {} }
-        ),
-        token: this.asset().address.address,
-        amount: uint256.bnToUint256(
-          p.changeAmt.multipliedBy(p.isDeposit ? 1 : -1).toWei()
-        )
-      });
-    });
-    if (actions.length === 0) return null;
-    if (isOverWeightAdjustment) {
-      return this.contract.populate("rebalance_weights", [actions]);
+    /**
+     * 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
+     */
+    async getRebalanceCall(
+        pools: Awaited<
+            ReturnType<typeof this.getRebalancedPositions>
+        >["changes"],
+        isOverWeightAdjustment: boolean // here, yield increase doesnt matter
+    ) {
+        const actions: any[] = [];
+        // sort to put withdrawals first
+        pools.sort((a, b) => (b.isDeposit ? -1 : 1));
+        pools.forEach((p) => {
+            if (p.changeAmt.eq(0)) return null;
+            actions.push({
+                pool_id: p.pool_id.address,
+                feature: new CairoCustomEnum(
+                    p.isDeposit ? { DEPOSIT: {} } : { WITHDRAW: {} }
+                ),
+                token: this.asset().address.address,
+                amount: uint256.bnToUint256(
+                    p.changeAmt.multipliedBy(p.isDeposit ? 1 : -1).toWei()
+                )
+            });
+        });
+        if (actions.length === 0) return null;
+        if (isOverWeightAdjustment) {
+            return this.contract.populate("rebalance_weights", [actions]);
+        }
+        return this.contract.populate("rebalance", [actions]);
     }
-    return this.contract.populate("rebalance", [actions]);
-  }
 
-  async getInvestmentFlows(pools: PoolInfoFull[]) {
-    const netYield = await this.netAPYGivenPools(pools);
+    async getInvestmentFlows(pools: PoolInfoFull[]) {
+        const netYield = await this.netAPYGivenPools(pools);
 
-    const baseFlow: IInvestmentFlow = {
-      title: "Your Deposit",
-      subItems: [
-        { key: `Net yield`, value: `${(netYield * 100).toFixed(2)}%` },
-        {
-          key: `Performance Fee`,
-          value: `${(this.metadata.additionalInfo.feeBps / 100).toFixed(2)}%`
-        }
-      ],
-      linkedFlows: [],
-      style: { backgroundColor: FlowChartColors.Purple.valueOf() }
-    };
+        const baseFlow: IInvestmentFlow = {
+            title: "Your Deposit",
+            subItems: [
+                { key: `Net yield`, value: `${(netYield * 100).toFixed(2)}%` },
+                {
+                    key: `Performance Fee`,
+                    value: `${(
+                        this.metadata.additionalInfo.feeBps / 100
+                    ).toFixed(2)}%`
+                }
+            ],
+            linkedFlows: [],
+            style: { backgroundColor: FlowChartColors.Purple.valueOf() }
+        };
 
-    let _pools = [...pools];
-    _pools = _pools.sort(
-      (a, b) => Number(b.amount.toString()) - Number(a.amount.toString())
-    );
-    _pools.forEach((p) => {
-      const flow: IInvestmentFlow = {
-        title: `Pool name: ${p.pool_name}`,
-        subItems: [
-          { key: `APY`, value: `${(p.APY.netApy * 100).toFixed(2)}%` },
-          {
-            key: "Weight",
-            value: `${(p.current_weight * 100).toFixed(2)} / ${(
-              p.max_weight * 100
-            ).toFixed(2)}%`
-          }
-        ],
-        linkedFlows: [],
-        style: p.amount.greaterThan(0)
-          ? { backgroundColor: FlowChartColors.Blue.valueOf() }
-          : { color: "gray" }
-      };
-      baseFlow.linkedFlows.push(flow);
-    });
-    return [baseFlow];
-  }
-
-  async harvest(acc: Account, endpoint = VESU_REWARDS_ENDPOINT) {
-    const vesuHarvest = new VesuHarvests(this.config);
-    const harvests = await vesuHarvest.getUnHarvestedRewards(this.address, endpoint);
-    const harvest = harvests[0];
-    const avnu = new AvnuWrapper();
-    let swapInfo: SwapInfo = {
-      token_from_address: harvest.token.address,
-      token_from_amount: uint256.bnToUint256(harvest.actualReward.toWei()),
-      token_to_address: this.asset().address.address,
-      token_to_amount: uint256.bnToUint256(0),
-      token_to_min_amount: uint256.bnToUint256(0),
-      beneficiary: this.address.address,
-      integrator_fee_amount_bps: 0,
-      integrator_fee_recipient: this.address.address,
-      routes: []
-    };
-    if (!this.asset().address.eqString(harvest.token.address)) {
-      const quote = await avnu.getQuotes(
-        harvest.token.address,
-        this.asset().address.address,
-        harvest.actualReward.toWei(),
-        this.address.address
-      );
-      swapInfo = await avnu.getSwapInfo(
-        quote,
-        this.address.address,
-        0,
-        this.address.address
-      );
+        let _pools = [...pools];
+        _pools = _pools.sort(
+            (a, b) => Number(b.amount.toString()) - Number(a.amount.toString())
+        );
+        _pools.forEach((p) => {
+            const flow: IInvestmentFlow = {
+                title: `Pool name: ${p.pool_name}`,
+                subItems: [
+                    {
+                        key: `APY`,
+                        value: `${(p.APY.netApy * 100).toFixed(2)}%`
+                    },
+                    {
+                        key: "Weight",
+                        value: `${(p.current_weight * 100).toFixed(2)} / ${(
+                            p.max_weight * 100
+                        ).toFixed(2)}%`
+                    }
+                ],
+                linkedFlows: [],
+                style: p.amount.greaterThan(0)
+                    ? { backgroundColor: FlowChartColors.Blue.valueOf() }
+                    : { color: "gray" }
+            };
+            baseFlow.linkedFlows.push(flow);
+        });
+        return [baseFlow];
     }
 
-    return [
-      this.contract.populate("harvest", [
-        harvest.rewardsContract.address,
-        {
-          id: harvest.claim.id,
-          amount: harvest.claim.amount.toWei(),
-          claimee: harvest.claim.claimee.address
-        },
-        harvest.proof,
-        swapInfo
-      ])
-    ];
-  }
-
-  /**
-   * 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
-   */
-  async getFee(
-    allowedPools: Array<PoolInfoFull>
-  ): Promise<Array<{ vToken: ContractAddr; fee: Web3Number }>> {
-    const assets = Web3Number.fromWei(
-      (await this.contract.total_assets()).toString(),
-      this.asset().decimals
-    );
-    const totalSupply = Web3Number.fromWei(
-      (await this.contract.total_supply()).toString(),
-      this.asset().decimals
-    );
-    const prevIndex = Web3Number.fromWei(
-      (await this.contract.get_previous_index()).toString(),
-      18
-    );
-    const currIndex = new Web3Number(1, 18)
-      .multipliedBy(assets)
-      .dividedBy(totalSupply);
-
-    logger.verbose(`Previous index: ${prevIndex.toString()}`);
-    logger.verbose(`Assets: ${assets.toString()}`);
-    logger.verbose(`Total supply: ${totalSupply.toString()}`);
-    logger.verbose(`Current index: ${currIndex.toNumber()}`);
-
-    if (currIndex.lt(prevIndex)) {
-      logger.verbose(
-        `getFee::Current index is less than previous index, no fees to be deducted`
-      );
-      return [];
+    async getPendingRewards(): Promise<HarvestInfo[]> {
+        const vesuHarvests = new VesuHarvests(this.config);
+        return await vesuHarvests.getUnHarvestedRewards(this.address);
     }
 
-    const indexDiff = currIndex.minus(prevIndex);
-    logger.verbose(`Index diff: ${indexDiff.toString()}`);
-    const numerator = totalSupply
-      .multipliedBy(indexDiff)
-      .multipliedBy(this.metadata.additionalInfo.feeBps);
-    const denominator = 10000;
-    let fee = numerator.dividedBy(denominator);
-    logger.verbose(`Fee: ${fee.toString()}`);
-
-    if (fee.lte(0)) {
-      return [];
+    async harvest(acc: Account) {
+        const pendingRewards = await this.getPendingRewards();
+        if (pendingRewards.length == 0) {
+            throw new Error(`No pending rewards found`);
+        }
+        const harvest = pendingRewards[0];
+        const avnu = new AvnuWrapper();
+        let swapInfo: SwapInfo = {
+            token_from_address: harvest.token.address,
+            token_from_amount: uint256.bnToUint256(
+                harvest.actualReward.toWei()
+            ),
+            token_to_address: this.asset().address.address,
+            token_to_amount: uint256.bnToUint256(0),
+            token_to_min_amount: uint256.bnToUint256(0),
+            beneficiary: this.address.address,
+            integrator_fee_amount_bps: 0,
+            integrator_fee_recipient: this.address.address,
+            routes: []
+        };
+        if (!this.asset().address.eqString(harvest.token.address)) {
+            const quote = await avnu.getQuotes(
+                harvest.token.address,
+                this.asset().address.address,
+                harvest.actualReward.toWei(),
+                this.address.address
+            );
+            swapInfo = await avnu.getSwapInfo(
+                quote,
+                this.address.address,
+                0,
+                this.address.address
+            );
+        }
+
+        return [
+            this.contract.populate("harvest", [
+                harvest.rewardsContract.address,
+                {
+                    id: harvest.claim.id,
+                    amount: harvest.claim.amount.toWei(),
+                    claimee: harvest.claim.claimee.address
+                },
+                harvest.proof,
+                swapInfo
+            ])
+        ];
     }
 
-    const fees: Array<{ vToken: ContractAddr; fee: Web3Number }> = [];
-    let remainingFee = fee.plus(
-      Web3Number.fromWei("100", this.asset().decimals)
-    );
+    /**
+     * 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
+     */
+    async getFee(
+        allowedPools: Array<PoolInfoFull>
+    ): Promise<Array<{ vToken: ContractAddr; fee: Web3Number }>> {
+        const assets = Web3Number.fromWei(
+            (await this.contract.total_assets()).toString(),
+            this.asset().decimals
+        );
+        const totalSupply = Web3Number.fromWei(
+            (await this.contract.total_supply()).toString(),
+            this.asset().decimals
+        );
+        const prevIndex = Web3Number.fromWei(
+            (await this.contract.get_previous_index()).toString(),
+            18
+        );
+        const currIndex = new Web3Number(1, 18)
+            .multipliedBy(assets)
+            .dividedBy(totalSupply);
+
+        logger.verbose(`Previous index: ${prevIndex.toString()}`);
+        logger.verbose(`Assets: ${assets.toString()}`);
+        logger.verbose(`Total supply: ${totalSupply.toString()}`);
+        logger.verbose(`Current index: ${currIndex.toNumber()}`);
+
+        if (currIndex.lt(prevIndex)) {
+            logger.verbose(
+                `getFee::Current index is less than previous index, no fees to be deducted`
+            );
+            return [];
+        }
+
+        const indexDiff = currIndex.minus(prevIndex);
+        logger.verbose(`Index diff: ${indexDiff.toString()}`);
+        const numerator = totalSupply
+            .multipliedBy(indexDiff)
+            .multipliedBy(this.metadata.additionalInfo.feeBps);
+        const denominator = 10000;
+        let fee = numerator.dividedBy(denominator);
+        logger.verbose(`Fee: ${fee.toString()}`);
+
+        if (fee.lte(0)) {
+            return [];
+        }
 
-    for (const pool of allowedPools) {
-      const vToken = pool.v_token;
-      const balance = pool.amount;
-
-      if (remainingFee.lte(balance)) {
-        fees.push({ vToken, fee: remainingFee });
-        break;
-      } else {
-        fees.push({ vToken, fee: Web3Number.fromWei(balance.toString(), 18) });
-        remainingFee = remainingFee.minus(
-          Web3Number.fromWei(balance.toString(), 18)
+        const fees: Array<{ vToken: ContractAddr; fee: Web3Number }> = [];
+        let remainingFee = fee.plus(
+            Web3Number.fromWei("100", this.asset().decimals)
         );
-      }
-    }
 
-    logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+        for (const pool of allowedPools) {
+            const vToken = pool.v_token;
+            const balance = pool.amount;
+
+            if (remainingFee.lte(balance)) {
+                fees.push({ vToken, fee: remainingFee });
+                break;
+            } else {
+                fees.push({
+                    vToken,
+                    fee: Web3Number.fromWei(balance.toString(), 18)
+                });
+                remainingFee = remainingFee.minus(
+                    Web3Number.fromWei(balance.toString(), 18)
+                );
+            }
+        }
 
-    return fees;
-  }
+        logger.verbose(`Fees: ${JSON.stringify(fees)}`);
+
+        return fees;
+    }
 }
 
-const _description = "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
+const _description =
+    "Automatically diversify {{TOKEN}} holdings into different Vesu pools while reducing risk and maximizing yield. Defi spring STRK Rewards are auto-compounded as well.";
 
 const _protocol: IProtocol = {
-  name: "Vesu",
-  logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
+    name: "Vesu",
+    logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
 };
 // need to fine tune better
 const _riskFactor: RiskFactor[] = [
-  { type: RiskType.SMART_CONTRACT_RISK, value: 0.5, weight: 25, reason: "Audited by CSC" },
-  { type: RiskType.COUNTERPARTY_RISK, value: 1, weight: 50, reason: "Reasonable max LTV ratios and Curated by well-known risk managers like Re7" },
-  { type: RiskType.ORACLE_RISK, value: 0.5, weight: 25, reason: "Uses Pragma price feeds, Most reputable price feed on Starknet" }
+    {
+        type: RiskType.SMART_CONTRACT_RISK,
+        value: 0.5,
+        weight: 25,
+        reason: "Audited by CSC"
+    },
+    {
+        type: RiskType.COUNTERPARTY_RISK,
+        value: 1,
+        weight: 50,
+        reason: "Reasonable max LTV ratios and Curated by well-known risk managers like Re7"
+    },
+    {
+        type: RiskType.ORACLE_RISK,
+        value: 0.5,
+        weight: 25,
+        reason: "Uses Pragma price feeds, Most reputable price feed on Starknet"
+    }
 ];
 const AUDIT_URL =
-  "https://assets.troves.fi/strkfarm/audit_report_vesu_and_ekubo_strats.pdf";
+    "https://assets.troves.fi/strkfarm/audit_report_vesu_and_ekubo_strats.pdf";
 
-const faqs: FAQ[] = [
-  {
-    question: "What is the Vesu Rebalancing Strategy?",
-    answer:
-      "The Vesu Rebalancing Strategy is an automated investment strategy that diversifies your holdings across multiple Vesu pools. It optimizes yield by rebalancing assets based on pool performance while adhering to risk constraints."
-  },
-  {
-    question: "Will I earn Vesu points?",
-    answer: "Yes, of course! You will earn Vesu points for your deposits."
-  },
-  {
-    question: "How does the strategy optimize yield?",
-    answer:
-      "The strategy calculates the weighted average APY across all pools and reallocates assets to maximize returns. It prioritizes high-performing pools while ensuring compliance with maximum weight constraints."
-  },
-  {
-    question: "What are the risks associated with this strategy?",
-    answer:
-      "The strategy involves usual DeFi risks such as smart contract vulnerabilities, counterparty risks, and oracle inaccuracies. However, we try our best to reduce these risks through audits and careful pool selection."
-  },
-  {
-    question: "How are fees calculated and deducted?",
-    answer:
-      "Fees are calculated based on the performance of the strategy and deducted proportionally from the total assets. We charge a 10% performance fee and is already accounted in the APY shown."
-  },
-  {
-    question: "What happens if a pool exceeds its maximum weight?",
-    answer:
-      "If a pool exceeds its maximum weight, the strategy rebalances by withdrawing excess funds and reallocating them to other pools with available capacity."
-  },
-  {
-    question: "Can I withdraw my assets at any time?",
-    answer:
-      "Yes, you can withdraw your assets at any time. In rare circumstances, if debt utilisation is high for certain pools on Vesu, it may not be possible to withdraw until markets restore balance."
-  },
-  {
-    question: "What happens to my Defi Spring STRK rewards?",
-    answer:
-      "STRK rewards are automatically harvested and reinvested into the strategy every week to maximize compounding returns."
-  },
-  {
-    question: "Is the strategy audited?",
-    answer:
-      <div>Yes, the strategy has been audited. You can review the audit report in our docs <a href="https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults#technical-details" style={{textDecoration: 'underline', marginLeft: '5px'}}>Here</a>.</div>
-  }
-];
+// Helper to create common risk object
+const getVesuRebalanceRisk = () => ({
+    riskFactor: _riskFactor,
+    netRisk:
+        _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+        _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(_riskFactor)
+});
 
-/**
- * Represents the Vesu Rebalance Strategies.
- */
-export const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[] =
-  [
-    {
-      name: "Vesu Fusion STRK",
-      description: _description,
-      address: ContractAddr.from(
-        "0x7fb5bcb8525954a60fde4e8fb8220477696ce7117ef264775a1770e23571929"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
-      ],
-      protocols: [_protocol],
-      auditUrl: AUDIT_URL,
-      maxTVL: Web3Number.fromWei("0", 18),
-      risk: {
-        riskFactor: _riskFactor,
-        netRisk:
-          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-        notARisks: getNoRiskTags(_riskFactor)
-      },
-      additionalInfo: {
+// Helper to create Vesu Rebalance strategy settings
+const createVesuRebalanceSettings = (tokenSymbol: string): StrategySettings => {
+    const depositToken = Global.getDefaultTokens().find(
+        (t) => t.symbol === tokenSymbol
+    )!;
+    return {
+        maxTVL: Web3Number.fromWei("0", depositToken.decimals),
+        isPaused: false,
+        liveStatus: StrategyLiveStatus.ACTIVE,
+        isAudited: true,
+        isInstantWithdrawal: true,
+        quoteToken: depositToken,
+        alerts: []
+    };
+};
+
+// Helper to create a Vesu Rebalance strategy
+const createVesuRebalanceStrategy = (
+    name: string,
+    tokenSymbol: string,
+    address: string
+): IStrategyMetadata<VesuRebalanceSettings> => ({
+    id: `vesu_fusion_${tokenSymbol.toLowerCase()}`,
+    name,
+    description: _description.replace("{{TOKEN}}", tokenSymbol),
+    address: ContractAddr.from(address),
+    launchBlock: 0,
+    type: "ERC4626" as const,
+    depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === tokenSymbol)!
+    ],
+    protocols: [_protocol],
+    auditUrl: AUDIT_URL,
+    settings: createVesuRebalanceSettings(tokenSymbol),
+    risk: getVesuRebalanceRisk(),
+    additionalInfo: {
         feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
     },
+    faqs,
+    contractDetails: [],
+    investmentSteps: []
+});
+
+// Shared security & redemption metadata for all Vesu strategies
+const VESU_SECURITY = {
+    auditStatus: AuditStatus.AUDITED,
+    sourceCode: {
+        type: SourceCodeType.OPEN_SOURCE,
+        contractLink: "https://github.com/trovesfi/troves-contracts"
+    },
+    accessControl: {
+        type: AccessControlType.STANDARD_ACCOUNT,
+        addresses: [ContractAddr.from("0x0")],
+        timeLock: "2 Days"
+    }
+};
+
+const VESU_REDEMPTION_INFO = {
+    instantWithdrawalVault: InstantWithdrawalVault.YES
+};
+
+const faqs: FAQ[] = [
     {
-      name: "Vesu Fusion ETH",
-      description: _description.replace("{{TOKEN}}", "ETH"),
-      address: ContractAddr.from(
-        "0x5eaf5ee75231cecf79921ff8ded4b5ffe96be718bcb3daf206690ad1a9ad0ca"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      auditUrl: AUDIT_URL,
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "ETH")!
-      ],
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 18),
-      risk: {
-        riskFactor: _riskFactor,
-        netRisk:
-          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-        notARisks: getNoRiskTags(_riskFactor)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
+        question: "What is the Vesu Rebalancing Strategy?",
+        answer: "The Vesu Rebalancing Strategy is an automated investment strategy that diversifies your holdings across multiple Vesu pools. It optimizes yield by rebalancing assets based on pool performance while adhering to risk constraints."
     },
     {
-      name: "Vesu Fusion USDC",
-      description: _description.replace("{{TOKEN}}", "USDC"),
-      address: ContractAddr.from(
-        "0xa858c97e9454f407d1bd7c57472fc8d8d8449a777c822b41d18e387816f29c"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      auditUrl: AUDIT_URL,
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-      ],
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 6),
-      risk: {
-        riskFactor: _riskFactor,
-        netRisk:
-          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-        notARisks: getNoRiskTags(_riskFactor)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
+        question: "Will I earn Vesu points?",
+        answer: "Yes, of course! You will earn Vesu points for your deposits."
     },
     {
-      name: "Vesu Fusion USDT",
-      description: _description.replace("{{TOKEN}}", "USDT"),
-      address: ContractAddr.from(
-        "0x115e94e722cfc4c77a2f15c4aefb0928c1c0029e5a57570df24c650cb7cec2c"
-      ),
-      launchBlock: 0,
-      type: "ERC4626",
-      depositTokens: [
-        Global.getDefaultTokens().find((t) => t.symbol === "USDT")!
-      ],
-      auditUrl: AUDIT_URL,
-      protocols: [_protocol],
-      maxTVL: Web3Number.fromWei("0", 6),
-      risk: {
-        riskFactor: _riskFactor,
-        netRisk:
-          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-        notARisks: getNoRiskTags(_riskFactor)
-      },
-      additionalInfo: {
-        feeBps: 1000
-      },
-      faqs,
-      contractDetails: [],
-      investmentSteps: []
-      // }, {
-      //     name: 'Vesu Fusion WBTC',
-      //     description: _description.replace('{{TOKEN}}', 'WBTC'),
-      //     address: ContractAddr.from('0x778007f8136a5b827325d21613803e796bda4d676fbe1e34aeab0b2a2ec027f'),
-      //     type: 'ERC4626',
-      //     depositTokens: [Global.getDefaultTokens().find(t => t.symbol === 'WBTC')!],
-      // auditUrl: AUDIT_URL,
-      //     protocols: [_protocol],
-      //     maxTVL: Web3Number.fromWei('0', 8),
-      //     risk: {
-      //         riskFactor: _riskFactor,
-      //         netRisk: _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-      //     },
-      //     additionalInfo: {
-      //         feeBps: 1000,
-      //     },
-      
+        question: "How does the strategy optimize yield?",
+        answer: "The strategy calculates the weighted average APY across all pools and reallocates assets to maximize returns. It prioritizes high-performing pools while ensuring compliance with maximum weight constraints."
+    },
+    {
+        question: "What are the risks associated with this strategy?",
+        answer: "The strategy involves usual DeFi risks such as smart contract vulnerabilities, counterparty risks, and oracle inaccuracies. However, we try our best to reduce these risks through audits and careful pool selection."
+    },
+    {
+        question: "How are fees calculated and deducted?",
+        answer: "Fees are calculated based on the performance of the strategy and deducted proportionally from the total assets. We charge a 10% performance fee and is already accounted in the APY shown."
+    },
+    {
+        question: "What happens if a pool exceeds its maximum weight?",
+        answer: "If a pool exceeds its maximum weight, the strategy rebalances by withdrawing excess funds and reallocating them to other pools with available capacity."
+    },
+    {
+        question: "Can I withdraw my assets at any time?",
+        answer: "Yes, you can withdraw your assets at any time. In rare circumstances, if debt utilisation is high for certain pools on Vesu, it may not be possible to withdraw until markets restore balance."
+    },
+    {
+        question: "What happens to my Defi Spring STRK rewards?",
+        answer: "STRK rewards are automatically harvested and reinvested into the strategy every week to maximize compounding returns."
+    },
+    {
+        question: "Is the strategy audited?",
+        answer: (
+            <div>
+                Yes, the strategy has been audited. You can review the audit
+                report in our docs{" "}
+                <a
+                    href="https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults#technical-details"
+                    style={{ textDecoration: "underline", marginLeft: "5px" }}
+                >
+                    Here
+                </a>
+                .
+            </div>
+        )
     }
 ];
 
+/**
+ * Represents the Vesu Rebalance Strategies.
+ */
+export const VesuRebalanceStrategies: IStrategyMetadata<VesuRebalanceSettings>[] =
+    [
+        createVesuRebalanceStrategy(
+            "Vesu Fusion STRK",
+            "STRK",
+            "0x7fb5bcb8525954a60fde4e8fb8220477696ce7117ef264775a1770e23571929"
+        ),
+        createVesuRebalanceStrategy(
+            "Vesu Fusion ETH",
+            "ETH",
+            "0x5eaf5ee75231cecf79921ff8ded4b5ffe96be718bcb3daf206690ad1a9ad0ca"
+        ),
+        createVesuRebalanceStrategy(
+            "Vesu Fusion USDC",
+            "USDC",
+            "0xa858c97e9454f407d1bd7c57472fc8d8d8449a777c822b41d18e387816f29c"
+        ),
+        createVesuRebalanceStrategy(
+            "Vesu Fusion USDT",
+            "USDT",
+            "0x115e94e722cfc4c77a2f15c4aefb0928c1c0029e5a57570df24c650cb7cec2c"
+        )
+    ];
+
 // auto assign contract details to each strategy
 VesuRebalanceStrategies.forEach((s) => {
-  // set contract details
-  s.contractDetails = [{
-    address: s.address,
-    name: "Vault",
-    sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/vesu_rebalance"
-  }, 
-  ...COMMON_CONTRACTS];
-  // set docs link
-  s.docs = "https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults"
-
-  // set description
-  s.description = highlightTextWithLinks(
-    _description.replace("{{TOKEN}}", s.depositTokens[0].symbol),
-    [{
-      highlight: "Vesu pools",
-      link: "https://vesu.xyz/pools",
-    }, {
-      highlight: "Defi spring STRK Rewards",
-      link: "https://defispring.starknet.io/"
-    }]
-  );
-
-  // add investment steps
-  s.investmentSteps = [
-    "Split the amount and Supply to configured Vesu pools",
-    "Monitor and Rebalance funds across multiple Vesu pools to maximize yield",
-    "Harvest and supply Defi Spring STRK rewards every week (Auto-compound)",
-  ]
-});
+    // set contract details
+    s.contractDetails = [
+        {
+            address: s.address,
+            name: "Vault",
+            sourceCodeUrl:
+                "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/vesu_rebalance"
+        },
+        ...COMMON_CONTRACTS
+    ];
+    // set docs link
+    s.docs =
+        "https://docs.troves.fi/p/strategies/vesu-fusion-rebalancing-vaults";
+
+    // set description
+    s.description = highlightTextWithLinks(
+        _description.replace("{{TOKEN}}", s.depositTokens[0].symbol),
+        [
+            {
+                highlight: "Vesu pools",
+                link: "https://vesu.xyz/pools"
+            },
+            {
+                highlight: "Defi spring STRK Rewards",
+                link: "https://defispring.starknet.io/"
+            }
+        ]
+    );
+
+    // add investment steps
+    s.investmentSteps = [
+        "Split the amount and Supply to configured Vesu pools",
+        "Monitor and Rebalance funds across multiple Vesu pools to maximize yield",
+        "Harvest and supply Defi Spring STRK rewards every week (Auto-compound)"
+    ];
+});