@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.41

package/src/strategies/ekubo-cl-vault.tsx

@@ -11,8 +11,16 @@ import {
   Protocols,
   RiskFactor,
   RiskType,
+  StrategyTag,
   TokenInfo,
   VaultPosition,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  VaultType,
+  StrategyLiveStatus,
+  UnwrapLabsCurator,
 } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
 import { assert } from "@/utils";
@@ -30,18 +38,25 @@ import EkuboMathAbi from "@/data/ekubo-math.abi.json";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 import { Global } from "@/global";
 import { AvnuWrapper, ERC20, SwapInfo } from "@/modules";
-import { APYInfo, BaseStrategy, SingleTokenInfo } from "./base-strategy";
+import {
+  APYInfo,
+  BaseStrategy,
+  SingleTokenInfo,
+  UserPositionCard,
+  UserPositionCardsInput,
+} from "./base-strategy";
 import { DualActionAmount } from "./base-strategy";
 import { DualTokenInfo } from "./base-strategy";
 import { log } from "winston";
 import { EkuboHarvests, HarvestInfo } from "@/modules/harvests";
 import { logger } from "@/utils/logger";
-import { COMMON_CONTRACTS } from "./constants";
 import { DepegRiskLevel, ImpermanentLossLevel, MarketRiskLevel, SmartContractRiskLevel } from "@/interfaces/risks";
-import { gql } from "@apollo/client";
+import { from, gql } from "@apollo/client";
 import apolloClient from "@/modules/apollo-client";
 import { binarySearch } from "@/utils/math-utils";
 import { PositionInfo } from "./universal-adapters/baseAdapter";
+import { Quote } from "@avnu/avnu-sdk";
+import { MY_ACCESS_CONTROL } from "./constants";
 
 export interface EkuboPoolKey {
   token0: ContractAddr;
@@ -118,7 +133,10 @@ export class EkuboCLVault extends BaseStrategy<
     pricer: PricerBase,
     metadata: IStrategyMetadata<CLVaultStrategySettings>
   ) {
-    super(config);
+    super(config, {
+      depositInputMode: "dual",
+      withdrawInputMode: "dual"
+    });
     this.pricer = pricer;
 
     assert(
@@ -296,7 +314,10 @@ export class EkuboCLVault extends BaseStrategy<
     return [this.contract.populate("handle_fees", [])];
   }
 
-  async getFeeHistory(timePeriod: '24h' | '7d' | '30d' | '3m' = '24h'): Promise<{
+  async getFeeHistory(
+    timePeriod: '24h' | '7d' | '30d' | '3m' | '6m' = '24h',
+    range?: { startTimestamp?: number; endTimestamp?: number }
+  ): Promise<{
     summary: DualTokenInfo,
     history: FeeHistory[]
   }> {
@@ -305,8 +326,15 @@ export class EkuboCLVault extends BaseStrategy<
         query ContractFeeEarnings(
           $timeframe: String!
           $contract: String!
+          $startTimestamp: Float
+          $endTimestamp: Float
         ) {
-          contractFeeEarnings(timeframe: $timeframe, contract: $contract) {
+          contractFeeEarnings(
+            timeframe: $timeframe
+            contract: $contract
+            startTimestamp: $startTimestamp
+            endTimestamp: $endTimestamp
+          ) {
             contract
             dailyEarnings {
               date
@@ -319,7 +347,9 @@ export class EkuboCLVault extends BaseStrategy<
       `,
       variables: {
         timeframe: timePeriod,
-        contract: this.address.address
+        contract: this.address.address,
+        startTimestamp: range?.startTimestamp,
+        endTimestamp: range?.endTimestamp
       },
       fetchPolicy: 'no-cache',
     });
@@ -418,22 +448,41 @@ export class EkuboCLVault extends BaseStrategy<
     const tvlBefore = await this._getTVL(blockBefore);
     const supplyBefore = await this.totalSupply(blockBefore);
     const priceBefore = await this.getCurrentPrice(blockBefore);
-
-    const tvlInToken0Now = (tvlNow.amount0
-      .multipliedBy(priceNow.price))
-      .plus(tvlNow.amount1);
-    const tvlPerShareNow = tvlInToken0Now
+    const poolKey = await this.getPoolKey(blockBefore);
+    logger.verbose(`priceBefore: ${priceBefore.price.toString()}`);
+    logger.verbose(`priceNow: ${priceNow.price.toString()}`);
+    logger.verbose(`tvlBefore: ${JSON.stringify(tvlBefore)}`);
+    logger.verbose(`tvlNow: ${JSON.stringify(tvlNow)}`);
+
+    const isQuoteTokenToken0 = this.metadata.additionalInfo.quoteAsset.address.eq(poolKey.token0);
+    logger.verbose(`isQuoteTokenToken0: ${isQuoteTokenToken0}`);
+    let tvlBeforeInBaseAsset = Web3Number.fromWei(0, this.metadata.additionalInfo.quoteAsset.decimals);
+    let tvlNowInBaseAsset = Web3Number.fromWei(0, this.metadata.additionalInfo.quoteAsset.decimals);
+    if (!isQuoteTokenToken0) {
+      tvlNowInBaseAsset = (tvlNow.amount0
+        .multipliedBy(priceNow.price))
+        .plus(tvlNow.amount1);
+      tvlBeforeInBaseAsset = (tvlBefore.amount0
+        .multipliedBy(priceBefore.price))
+        .plus(tvlBefore.amount1);
+    } else {
+      tvlNowInBaseAsset = (tvlNow.amount1
+        .multipliedBy(1 / priceNow.price))
+        .plus(tvlNow.amount0);
+      tvlBeforeInBaseAsset = (tvlBefore.amount1
+        .multipliedBy(1 / priceBefore.price))
+        .plus(tvlBefore.amount0);
+    }
+    const tvlPerShareNow = tvlNowInBaseAsset
       .multipliedBy(1e18)
       .dividedBy(adjustedSupplyNow.toString());
-    const tvlInToken0Bf = (tvlBefore.amount0
-      .multipliedBy(priceBefore.price))
-      .plus(tvlBefore.amount1);
-    const tvlPerShareBf = tvlInToken0Bf
+
+    const tvlPerShareBf = tvlBeforeInBaseAsset
       .multipliedBy(1e18)
       .dividedBy(supplyBefore.toString());
     const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
-    logger.verbose(`tvlInToken0Now: ${tvlInToken0Now.toString()}`);
-    logger.verbose(`tvlInToken0Bf: ${tvlInToken0Bf.toString()}`);
+    logger.verbose(`tvlNowInBaseAsset: ${tvlNowInBaseAsset.toString()}`);
+    logger.verbose(`tvlBeforeInBaseAsset: ${tvlBeforeInBaseAsset.toString()}`);
     logger.verbose(`tvlPerShareNow: ${tvlPerShareNow.toString()}`);
     logger.verbose(`tvlPerShareBf: ${tvlPerShareBf.toString()}`);
     logger.verbose(`Price before: ${priceBefore.price.toString()}`);
@@ -451,6 +500,204 @@ export class EkuboCLVault extends BaseStrategy<
     return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
   }
 
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Ekubo CL Vault strategy
+   */
+  getLifetimeEarnings(
+    userTVL: SingleTokenInfo,
+    investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+  ): any {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
+
+  /**
+   * Calculates realized APY based on TVL per share growth, always valued in USDC.
+   * This is a vault-level metric (same for all users) and works for all strategies,
+   * regardless of quote asset configuration.
+   */
+  async getUserRealizedAPY(
+    blockIdentifier: BlockIdentifier = "latest",
+    sinceBlocks = 600000
+  ): Promise<number> {
+    throw new Error("getUserRealizedAPY not implemented yet for Ekubo CL Vault strategy");
+
+    /*
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+    );
+
+    // TVL amounts (in token units) at current reference block
+    const tvlNow = await this._getTVL(blockIdentifier);
+    const supplyNow = await this.totalSupply(blockIdentifier);
+
+    // Determine current block number and timestamp
+    let blockNow =
+      typeof blockIdentifier == "number"
+        ? blockIdentifier
+        : (await this.config.provider.getBlockLatestAccepted()).block_number;
+    const blockNowTime =
+      typeof blockIdentifier == "number"
+        ? (await this.config.provider.getBlockWithTxs(blockIdentifier))
+            .timestamp
+        : new Date().getTime() / 1000;
+
+    // Look back window, but never before launch block
+    const blockBefore = Math.max(
+      Number(blockNow) - sinceBlocks,
+      this.metadata.launchBlock
+    );
+
+    // Adjust current supply by subtracting harvest reward shares (same idea as netSharesBasedTrueAPY)
+    const adjustedSupplyNow = supplyNow.minus(
+      await this.getHarvestRewardShares(blockBefore, Number(blockNow))
+    );
+
+    // Historical block info and TVL
+    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+      blockBefore
+    );
+    const tvlBefore = await this._getTVL(blockBefore);
+    const supplyBefore = await this.totalSupply(blockBefore);
+
+    // Always value TVL in USDC using the pricer for both tokens at both blocks
+    const token0Info = this.metadata.depositTokens[0];
+    const token1Info = this.metadata.depositTokens[1];
+
+    const P0Now = await this.pricer.getPrice(
+      token0Info.symbol,
+      Number(blockNow)
+    );
+    const P1Now = await this.pricer.getPrice(
+      token1Info.symbol,
+      Number(blockNow)
+    );
+    const P0Before = await this.pricer.getPrice(
+      token0Info.symbol,
+      blockBefore
+    );
+    const P1Before = await this.pricer.getPrice(
+      token1Info.symbol,
+      blockBefore
+    );
+
+    // Convert token balances to USDC TVL using current and historical prices
+    const tvlNowUsdNumber =
+      Number(tvlNow.amount0.toFixed(13)) * P0Now.price +
+      Number(tvlNow.amount1.toFixed(13)) * P1Now.price;
+    const tvlBeforeUsdNumber =
+      Number(tvlBefore.amount0.toFixed(13)) * P0Before.price +
+      Number(tvlBefore.amount1.toFixed(13)) * P1Before.price;
+
+    // Represent USDC TVL as Web3Number with 6 decimals (USDC standard)
+    const tvlNowInUSDC = new Web3Number(
+      tvlNowUsdNumber.toFixed(13),
+      6
+    );
+    const tvlBeforeInUSDC = new Web3Number(
+      tvlBeforeUsdNumber.toFixed(13),
+      6
+    );
+
+    const tvlPerShareNow = tvlNowInUSDC
+      .multipliedBy(1e18)
+      .dividedBy(adjustedSupplyNow.toString());
+
+    const tvlPerShareBf = tvlBeforeInUSDC
+      .multipliedBy(1e18)
+      .dividedBy(supplyBefore.toString());
+
+    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => token0=${token0Info.symbol}, token1=${token1Info.symbol}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => P0Now=${P0Now.price}, P1Now=${P1Now.price}, P0Before=${P0Before.price}, P1Before=${P1Before.price}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => raw tvlNow amounts: token0=${tvlNow.amount0.toString()}, token1=${tvlNow.amount1.toString()}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => raw tvlBefore amounts: token0=${tvlBefore.amount0.toString()}, token1=${tvlBefore.amount1.toString()}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => tvlNowUsdNumber=${tvlNowUsdNumber}, tvlBeforeUsdNumber=${tvlBeforeUsdNumber}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => tvlNowInUSDC: ${tvlNowInUSDC.toString()}, tvlBeforeInUSDC: ${tvlBeforeInUSDC.toString()}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => tvlPerShareNow: ${tvlPerShareNow.toString()}, tvlPerShareBf: ${tvlPerShareBf.toString()}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => Supply before: ${supplyBefore.toString()}, Supply now (adjusted): ${adjustedSupplyNow.toString()}`
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: getUserRealizedAPY => Time diff in seconds: ${timeDiffSeconds}`
+    );
+
+    const apyForGivenBlocks =
+      Number(
+        tvlPerShareNow
+          .minus(tvlPerShareBf)
+          .multipliedBy(10000)
+          .dividedBy(tvlPerShareBf)
+      ) / 10000;
+
+    return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
+    */
+  }
+
+  async getMaxTVL(): Promise<Web3Number> {
+    // This strategy doesn't have a maxTVL so returning 0 simply
+    return new Web3Number('0', 18);
+  }
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const quoteToken = this.metadata.additionalInfo.quoteAsset;
+    const [userTVL, quotePrice] = await Promise.all([
+      this.getUserTVL(input.user),
+      this.pricer.getPrice(quoteToken.symbol),
+    ]);
+
+    const token0IsQuote = userTVL.token0.tokenInfo.address.eq(quoteToken.address);
+    const token1IsQuote = userTVL.token1.tokenInfo.address.eq(quoteToken.address);
+    const token0QuoteAmount = token0IsQuote
+      ? userTVL.token0.amount.toNumber()
+      : userTVL.token0.usdValue / (quotePrice.price || 1);
+    const token1QuoteAmount = token1IsQuote
+      ? userTVL.token1.amount.toNumber()
+      : userTVL.token1.usdValue / (quotePrice.price || 1);
+    const totalQuoteAmount = token0QuoteAmount + token1QuoteAmount;
+    const quoteAmountDisplay = Number.isFinite(totalQuoteAmount)
+      ? totalQuoteAmount.toLocaleString("en-US", {
+          maximumFractionDigits: quoteToken.displayDecimals ?? 2,
+          minimumFractionDigits: 0,
+        })
+      : "0";
+    const allocationValue = `${this.formatTokenAmountForCard(userTVL.token0.amount, userTVL.token0.tokenInfo)} / ${this.formatTokenAmountForCard(userTVL.token1.amount, userTVL.token1.tokenInfo)}`;
+    const allocationSubValue = `${this.formatUSDForCard(userTVL.token0.usdValue)} / ${this.formatUSDForCard(userTVL.token1.usdValue)}`;
+
+    const cards: UserPositionCard[] = [
+      {
+        title: "Your Holdings",
+        tooltip: `${quoteToken.symbol} equivalent value of your Ekubo position`,
+        value: `${quoteAmountDisplay} ${quoteToken.symbol}`,
+        subValue: `≈ ${this.formatUSDForCard(userTVL.usdValue)}`,
+        subValueColor: "positive",
+      },
+      {
+        title: "Holding Allocation",
+        tooltip: "Split of your position between token0 and token1",
+        value: allocationValue,
+        subValue: `≈ ${allocationSubValue}`,
+        subValueColor: "default",
+      },
+    ];
+    return cards;
+  }
+
   async feeBasedAPY(
     timeperiod: '24h' | '7d' | '30d' | '3m' = '24h'
   ): Promise<number> {
@@ -485,20 +732,15 @@ export class EkuboCLVault extends BaseStrategy<
     blockIdentifier: BlockIdentifier = "latest",
     sinceBlocks = 600000,
     timeperiod: '24h' | '7d' | '30d' | '3m' = '24h' // temp thing for fee based APY
-  ): Promise<APYInfo> {
-    const isUSDCQouteToken = this.metadata.additionalInfo.quoteAsset.symbol === "USDC";
+  ): Promise<number> {
+    // ! switch to USDC later
+    const isUSDCQouteToken = this.metadata.additionalInfo.quoteAsset.symbol === "USDC.e" || this.metadata.additionalInfo.quoteAsset.symbol === "USDC";
     if (!isUSDCQouteToken) {
       // good for LSTs and stables
-        return {
-        net: await this.netSharesBasedTrueAPY(blockIdentifier, sinceBlocks),
-        splits: []
-      };
+      return await this.netSharesBasedTrueAPY(blockIdentifier, sinceBlocks);
     } else {
       // good for non-stables
-      return {
-        net: await this.feeBasedAPY(timeperiod),
-        splits: []
-      };
+      return await this.feeBasedAPY(timeperiod);
     }
   }
 
@@ -559,8 +801,14 @@ export class EkuboCLVault extends BaseStrategy<
       assets.amount1.toString(),
       token1Info.decimals
     );
-    const P0 = await this.pricer.getPrice(token0Info.symbol);
-    const P1 = await this.pricer.getPrice(token1Info.symbol);
+
+    // Convert blockIdentifier to block number for pricer if it's a number
+    const blockNumber = typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint'
+      ? Number(blockIdentifier)
+      : undefined;
+
+    const P0 = await this.pricer.getPrice(token0Info.symbol, blockNumber);
+    const P1 = await this.pricer.getPrice(token1Info.symbol, blockNumber);
     const token0Usd = Number(amount0.toFixed(13)) * P0.price;
     const token1Usd = Number(amount1.toFixed(13)) * P1.price;
 
@@ -627,8 +875,26 @@ export class EkuboCLVault extends BaseStrategy<
     const P1 = await this.pricer.getPrice(token1Info.symbol);
     const token0Usd = Number(amount0.toFixed(13)) * P0.price;
     const token1Usd = Number(amount1.toFixed(13)) * P1.price;
+    const totalUsdValue = token0Usd + token1Usd;
+
+    if (
+      (totalUsdValue === 0 || token0Usd === 0 || token1Usd === 0 || amount0.eq(0) || amount1.eq(0)) &&
+      this.metadata.settings?.liveStatus === StrategyLiveStatus.ACTIVE
+    ) {
+      logger.warn(
+        `${this.metadata.name}:getTVL - Zero value detected: ` +
+        `usdValue=${totalUsdValue}, ` +
+        `amount0=${amount0.toString()}, ` +
+        `amount1=${amount1.toString()}, ` +
+        `token0Price=${P0.price}, ` +
+        `token1Price=${P1.price}, ` +
+        `token0Usd=${token0Usd}, ` +
+        `token1Usd=${token1Usd}`
+      );
+    }
+
     return {
-      usdValue: token0Usd + token1Usd,
+      usdValue: totalUsdValue,
       token0: {
         tokenInfo: token0Info,
         amount: amount0,
@@ -1026,6 +1292,12 @@ export class EkuboCLVault extends BaseStrategy<
         amount1: availableAmount1.minus(y),
         ratio: 0,
       };
+    } else if (ratio.eq(Infinity)) {
+      return {
+        amount0: availableAmount0,
+        amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+        ratio: Infinity,
+      };
     }
     return {
       amount0: availableAmount0.plus(x),
@@ -1075,7 +1347,12 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async getSwapInfoToHandleUnused(considerRebalance: boolean = true, newBounds: EkuboBounds | null = null, maxIterations = 20, priceRatioPrecision = 4): Promise<SwapInfo> {
+  async getSwapInfoToHandleUnused(
+    considerRebalance: boolean = true,
+    newBounds: EkuboBounds | null = null,
+    maxIterations = 20, priceRatioPrecision = 4,
+    getQuoteCallback: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote> = this.avnu.getQuotes
+  ): Promise<SwapInfo> {
     const poolKey = await this.getPoolKey();
 
     // fetch current unused balances of vault
@@ -1140,7 +1417,8 @@ export class EkuboCLVault extends BaseStrategy<
       token1Bal,
       ekuboBounds,
       maxIterations,
-      priceRatioPrecision
+      priceRatioPrecision,
+      getQuoteCallback
     );
   }
 
@@ -1186,6 +1464,7 @@ export class EkuboCLVault extends BaseStrategy<
     const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal)
       ? poolKey.token0
       : poolKey.token1;
+    logger.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
     // The other token is the one to buy
     const tokenToBuy =
       tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
@@ -1210,13 +1489,13 @@ export class EkuboCLVault extends BaseStrategy<
   /**
    * @description Calculates swap info based on given amounts of token0 and token1
    * Use token0 and token1 balances to determine the expected amounts for new bounds
-   * @param poolKey 
-   * @param token0Bal 
-   * @param token1Bal 
+   * @param poolKey
+   * @param token0Bal
+   * @param token1Bal
    * @param bounds // new bounds
-   * @param maxIterations 
+   * @param maxIterations
    * @returns {Promise<SwapInfo>}
-   * 
+   *
    */
   async getSwapInfoGivenAmounts(
     poolKey: EkuboPoolKey,
@@ -1224,7 +1503,8 @@ export class EkuboCLVault extends BaseStrategy<
     token1Bal: Web3Number,
     bounds: EkuboBounds,
     maxIterations: number = 20,
-    priceRatioPrecision: number = 4
+    priceRatioPrecision: number = 4,
+    getQuoteCallback: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote> = this.avnu.getQuotes
   ): Promise<SwapInfo> {
     logger.verbose(
       `${
@@ -1279,12 +1559,7 @@ export class EkuboCLVault extends BaseStrategy<
       }
 
       // Get a quote for swapping the calculated amount
-      const quote = await this.avnu.getQuotes(
-        tokenToSell.address,
-        tokenToBuy.address,
-        amountToSell.toWei(),
-        this.address.address
-      );
+      const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
 
       // If all of the token is to be swapped, return the swap info directly
       if (remainingSellAmount.eq(0)) {
@@ -1394,8 +1669,11 @@ export class EkuboCLVault extends BaseStrategy<
    * @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
    */
   async rebalanceIter(
     swapInfo: SwapInfo,
@@ -1405,15 +1683,23 @@ export class EkuboCLVault extends BaseStrategy<
     retry = 0,
     lowerLimit = 0n,
     upperLimit = 0n,
-    MAX_RETRIES = 40
+    MAX_RETRIES = 40,
+    sameErrorCount: { count: number, error: null | string } = { count: 0, error: null },
+    MAX_SAME_ERROR_COUNT = 10
   ): Promise<Call[]> {
 
     logger.verbose(
       `Rebalancing ${this.metadata.name}: ` +
-        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
 
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
+
     const fromAmount = uint256.uint256ToBN(swapInfo.token_from_amount);
+    const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -1433,8 +1719,8 @@ export class EkuboCLVault extends BaseStrategy<
       );
 
       const newSwapInfo = { ...swapInfo };
-      const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18); // 18 is ok, as its toWei eventually anyways
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (
         err.message.includes("invalid token0 balance") ||
         err.message.includes("invalid token0 amount")
@@ -1487,11 +1773,43 @@ export class EkuboCLVault extends BaseStrategy<
           }
           newSwapInfo.token_from_amount = uint256.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again.
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again.
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
+        // just try again.
       } else {
         logger.error("Unexpected error:", err);
         throw err;
       }
       newSwapInfo.token_to_min_amount = uint256.bnToUint256("0");
+
+      // if (uint256.uint256ToBN(newSwapInfo.token_from_amount) == fromAmount && sameErrorCount.error == 'loop-stuck') {
+      //   logger.error("Swap amount did not change, cannot proceed");
+      //   sameErrorCount = { count: MAX_SAME_ERROR_COUNT, error: null };
+      // }
       return this.rebalanceIter(
         newSwapInfo,
         acc,
@@ -1499,7 +1817,10 @@ export class EkuboCLVault extends BaseStrategy<
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }
@@ -1592,20 +1913,34 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async harvest(acc: Account, maxIterations = 20, priceRatioPrecision = 4): Promise<Call[]> {
+  async getPendingRewards(): Promise<HarvestInfo[]> {
     const ekuboHarvests = new EkuboHarvests(this.config);
-    const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
-      this.address
-    );
+    return await ekuboHarvests.getUnHarvestedRewards(this.address);
+  }
+
+  async harvest(acc: Account, maxIterations = 20, priceRatioPrecision = 4, minRewardAmount: Web3Number = new Web3Number(0, 18)): Promise<Call[]> {
+    const _pendingRewards = await this.getPendingRewards();
+    const pendingRewards = _pendingRewards.filter(claim => claim.actualReward.greaterThanOrEqualTo(minRewardAmount));
+    if (pendingRewards.length == 0) {
+      logger.verbose(`${EkuboCLVault.name}: harvest => no pending rewards found`);
+      return [];
+    }
+    // get necessary info for the harvest
     const poolKey = await this.getPoolKey();
     const token0Info = await Global.getTokenInfoFromAddr(poolKey.token0);
     const token1Info = await Global.getTokenInfoFromAddr(poolKey.token1);
     const bounds = await this.getCurrentBounds();
     logger.verbose(
-      `${EkuboCLVault.name}: harvest => unClaimedRewards: ${unClaimedRewards.length}`
+      `${EkuboCLVault.name}: harvest => unClaimedRewards: ${pendingRewards.length}`
     );
+
+    // execute the harvest
     const calls: Call[] = [];
-    for (let claim of unClaimedRewards) {
+    // do one at a time.
+    const chosenClaim = pendingRewards[0];
+    logger.info(`${EkuboCLVault.name}: harvest => doing one at a time`);
+    logger.info(`${EkuboCLVault.name}: harvest => chosenClaim -> Claim ID: ${chosenClaim.claim.id}, Amount: ${chosenClaim.claim.amount.toString()}, actualAmount: ${chosenClaim.actualReward.toString()}, addr: ${chosenClaim.claim.claimee.toString()}`);
+    for (let claim of [chosenClaim]) {
       const fee = claim.claim.amount
         .multipliedBy(this.metadata.additionalInfo.feeBps)
         .dividedBy(10000);
@@ -1653,8 +1988,8 @@ export class EkuboCLVault extends BaseStrategy<
 
   /**
    * @description This funciton requires atleast one of the pool tokens to be reward token
-   * i.e. STRK. 
-   * @param params 
+   * i.e. STRK.
+   * @param params
    */
   async _handleRewardAndVaultTokenMatchHarvest(params: {
     claim: HarvestInfo;
@@ -1678,60 +2013,50 @@ export class EkuboCLVault extends BaseStrategy<
     logger.verbose(
       `${
         EkuboCLVault.name
-      }: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
-    );
-
-    // THis function cannot handle swapping of non-STRK pool,
-    // bcz atleast one of token0Amt or token1Amt are in STRK terms. 
-    const swapInfo = await this.getSwapInfoGivenAmounts(
-      poolKey,
-      token0Amt,
-      token1Amt,
-      bounds,
-      maxIterations,
-      priceRatioPrecision
-    );
-    swapInfo.token_to_address = token0Info.address.address;
-    logger.verbose(
-      `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+      }: harvest => token0Amt: ${token0Amt.toFixed(18)}, token1Amt: ${token1Amt.toFixed(18)}`
     );
 
     logger.verbose(
       `${EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
     );
-    const harvestEstimateCall = async (swapInfo1: SwapInfo) => {
-      const swap1Amount = Web3Number.fromWei(
-        uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
-        18 // cause its always STRK?
+    const claimTokenInfo = await Global.getTokenInfoFromAddr(claim.token);
+    const harvestEstimateCall = async (baseSwapInfo: SwapInfo) => {
+      // - the base swap if actual swap from claim token to non-claim token
+      // - the other swap is just claim token to claim token (e.g. STRK to STRK)
+      // which is just dummy
+      let baseSwapAmount = Web3Number.fromWei(
+        uint256.uint256ToBN(baseSwapInfo.token_from_amount).toString(),
+        claimTokenInfo.decimals
       ).minimum(
-        postFeeAmount.toFixed(18) // cause always strk
+        postFeeAmount.toFixed(claimTokenInfo.decimals)
       ); // ensure we don't swap more than we have
-      swapInfo.token_from_amount = uint256.bnToUint256(swap1Amount.toWei());
-      swapInfo.token_to_min_amount = uint256.bnToUint256(
-        swap1Amount.multipliedBy(0).toWei() // placeholder
-      ); // 0.01% slippage
+      if (baseSwapAmount.lt(0.0001)) {
+        baseSwapAmount = new Web3Number(0, claimTokenInfo.decimals);
+      }
+      baseSwapInfo.token_from_amount = uint256.bnToUint256(baseSwapAmount.toWei());
 
+      const isToken0ClaimToken = claim.token.eq(poolKey.token0);
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
+        `${EkuboCLVault.name}: harvest => isToken0ClaimToken: ${isToken0ClaimToken}, baseSwapAmount: ${baseSwapAmount}`
       );
 
-      const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
+      const remainingAmount = postFeeAmount.minus(baseSwapAmount).maximum(0);
       logger.verbose(
         `${EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
       );
-      const swapInfo2 = {
-        ...swapInfo,
-        token_from_amount: uint256.bnToUint256(remainingAmount.toWei()),
-      };
-      swapInfo2.token_to_address = token1Info.address.address;
+
+      // obv, same to same
+      let dummySwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, claim.token);
+      dummySwapInfo.token_from_amount = uint256.bnToUint256(remainingAmount.toWei());
+
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-          swapInfo
+        `${EkuboCLVault.name}: harvest => dummySwapInfo: ${JSON.stringify(
+          dummySwapInfo
         )}`
       );
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
-          swapInfo2
+        `${EkuboCLVault.name}: harvest => baseSwapInfo: ${JSON.stringify(
+          baseSwapInfo
         )}`
       );
       const calldata = [
@@ -1742,18 +2067,41 @@ export class EkuboCLVault extends BaseStrategy<
           claimee: claim.claim.claimee.address,
         },
         claim.proof.map((p) => num.getDecimalString(p)),
-        swapInfo,
-        swapInfo2,
+        isToken0ClaimToken ? dummySwapInfo : baseSwapInfo, // is token0 claim token, its just dummy swap
+        isToken0ClaimToken ? baseSwapInfo : dummySwapInfo,
       ];
-      logger.verbose(
-        `${EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
-          calldata
-        )}`
-      );
       return [this.contract.populate("harvest", calldata)];
     };
+
+    // if token0 == claim token, then the base swapInfo is from claim token to token1
+    // if token1 == claim token, then the base swapInfo is from claim token to token0
+    const isToken0ClaimToken = claim.token.eq(poolKey.token0);
+    let baseSwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, isToken0ClaimToken ? token1Info.address : token0Info.address);
+    baseSwapInfo.token_from_amount = uint256.bnToUint256(postFeeAmount.toWei()); // we try to swap all to start with
+
+    // if token0 != claim token, then we swap from claim token to token0
+    if (postFeeAmount.greaterThan(0) && !isToken0ClaimToken) {
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token0Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    } else if (postFeeAmount.greaterThan(0) && isToken0ClaimToken) {
+      // if token0 == claim token, then we swap from claim token to token1
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    }
     const _callsFinal = await this.rebalanceIter(
-      swapInfo,
+      baseSwapInfo,
       acc,
       harvestEstimateCall,
       claim.token.eq(poolKey.token0),
@@ -1772,9 +2120,9 @@ export class EkuboCLVault extends BaseStrategy<
 
   /**
    * @description This function handles harvesting of reward token that is not the same as any of the vault token
-   * i.e. STRK is not part of vault tokens like BTC/ETH 
-   * @param params 
-   * @returns 
+   * i.e. STRK is not part of vault tokens like BTC/ETH
+   * @param params
+   * @returns
    */
   async _handleRewardAndVaultTokenMismatchHarvest(params: {
     claim: HarvestInfo;
@@ -1812,7 +2160,7 @@ export class EkuboCLVault extends BaseStrategy<
     return [harvestCall];
   }
 
-  // given an amount (i.e. portion of reward to use to swap to token0), returns info on increasing or decreasing 
+  // given an amount (i.e. portion of reward to use to swap to token0), returns info on increasing or decreasing
   // amount for binary search
   async harvestMismatchEstimateCallFn(params: {
     postFeeAmount: Web3Number;
@@ -1823,39 +2171,47 @@ export class EkuboCLVault extends BaseStrategy<
   }) {
     const { postFeeAmount, claim, token0Info, token1Info, acc } = params;
     let harvestCall: Call | null = null;
+    logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => postFeeAmount: ${postFeeAmount.toString()}`);
 
+    let attempt = 0;
+    let MAX_ATTEMPTS = 50;
     const binarySearchCallbackFn = async (mid: bigint) => {
+      attempt++;
+      logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => mid: ${mid}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
       const rewardPart2 = BigInt(postFeeAmount.toWei()) - mid;
       const avnuWrapper = new AvnuWrapper();
       const beneficiary = this.address.address;
 
       // get quote for 1st part
-      const quote1 = await avnuWrapper.getQuotes(
+      const quote1Prom = avnuWrapper.getQuotes(
         claim.token.address,
         token0Info.address.address,
         mid.toString(),
         beneficiary
       );
+      const quote2Prom = avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        rewardPart2.toString(),
+        beneficiary
+      );
+      const [quote1, quote2] = await Promise.all([quote1Prom, quote2Prom]);
+
       // default min amount is ok
       const swapInfo1 = await avnuWrapper.getSwapInfo(
         quote1,
         beneficiary,
-        0,
+        0, // fee bps
         beneficiary
       );
 
       // get quote for 2nd part
-      const quote2 = await avnuWrapper.getQuotes(
-        claim.token.address,
-        token1Info.address.address,
-        rewardPart2.toString(),
-        beneficiary
-      );
+
       // default min amount is ok
       const swapInfo2 = await avnuWrapper.getSwapInfo(
         quote2,
         beneficiary,
-        0,
+        0, // fee bps
         beneficiary
       );
 
@@ -1874,27 +2230,36 @@ export class EkuboCLVault extends BaseStrategy<
         ];
         harvestCall = this.contract.populate("harvest", calldata)
         const gas = await acc.estimateInvokeFee(harvestCall);
+        logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => gas: ${gas.overall_fee.toString()}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return 'found';
       } catch (err: any) {
         if (err.message.includes('invalid token0 amount')) {
+          logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token0 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           // too much token0 amount left, may be swap less to token0
           return 'go_low';
         } else if (err.message.includes('invalid token1 amount')) {
+          logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token1 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           // too much token1 balance left, may be swap more to token0
           return 'go_high';
         }
+        logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => error: ${err.message}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return 'retry';
       }
     }
 
     // run the binary search
     await binarySearch(0n, BigInt(postFeeAmount.toWei()), binarySearchCallbackFn);
-   
+
     return harvestCall;
   }
 
   async getInvestmentFlows() {
-    const netYield = await this.netAPY();
+    // for LSTs, we use 30d, else 7d for the yield calculation
+    // TODO Make the block compute more dynamic
+    const blocksDiff = this.metadata.additionalInfo.lstContract
+      ? 600000
+      : 600000 / 4;
+    const netYield = await this.netAPY("latest", blocksDiff, "7d" as any);
     const poolKey = await this.getPoolKey();
 
     const linkedFlow: IInvestmentFlow = {
@@ -1915,7 +2280,7 @@ export class EkuboCLVault extends BaseStrategy<
       id: "base",
       title: "Your Deposit",
       subItems: [
-        { key: `Net yield`, value: `${(netYield.net * 100).toFixed(2)}%` },
+        { key: `Net yield`, value: `${(netYield * 100).toFixed(2)}%` },
         {
           key: `Performance Fee`,
           value: `${(this.metadata.additionalInfo.feeBps / 100).toFixed(2)}%`,
@@ -1931,8 +2296,8 @@ export class EkuboCLVault extends BaseStrategy<
       subItems: [
         {
           key: "Range selection",
-          value: (typeof this.metadata.additionalInfo.newBounds == 'string') ? 
-          this.metadata.additionalInfo.newBounds : 
+          value: (typeof this.metadata.additionalInfo.newBounds == 'string') ?
+          this.metadata.additionalInfo.newBounds :
           `${
             this.metadata.additionalInfo.newBounds.lower *
             Number(poolKey.tick_spacing)
@@ -2053,7 +2418,11 @@ function getLSTFAQs(lstSymbol: string): FAQ[] {
   ]
 }
 
+const vaultTypeDescription = 'Automatically collects fees and rebalances positions on Ekubo to optimize yield';
+const vaultType = VaultType.AUTOMATED_LP;
+
 const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
+  id: "ekubo_cl_xstrkstrk",
   name: "Ekubo xSTRK/STRK",
   description: <></>,
   address: ContractAddr.from(
@@ -2061,6 +2430,10 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
   ),
   launchBlock: 1209881,
   type: "Other",
+  vaultType: {
+    type: vaultType,
+    description: vaultTypeDescription
+  },
   // must be same order as poolKey token0 and token1
   depositTokens: [
     Global.getDefaultTokens().find((t) => t.symbol === "xSTRK")!,
@@ -2068,7 +2441,7 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
   ],
   protocols: [_protocol],
   auditUrl: AUDIT_URL,
-  maxTVL: Web3Number.fromWei("0", 18),
+  curator: UnwrapLabsCurator,
   risk: {
     riskFactor: _lstPoolRiskFactors,
     netRisk:
@@ -2078,6 +2451,10 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
   },
   apyMethodology:
     "APY based on 30-day historical performance, including fees and rewards.",
+  realizedApyMethodology: "The realizedAPY is based on past 14 days performance by the vault",
+  feeBps: {
+    performanceFeeBps: 1000,
+  },
   additionalInfo: {
     newBounds: {
       lower: -1,
@@ -2094,270 +2471,589 @@ const xSTRKSTRK: IStrategyMetadata<CLVaultStrategySettings> = {
     },
     quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
   },
+  settings: {
+    isAudited: true,
+    isPaused: false,
+    liveStatus: StrategyLiveStatus.ACTIVE,
+    isInstantWithdrawal: true,
+    hideNetEarnings: true,
+    isTransactionHistDisabled: true,
+    quoteToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
+    alerts: [
+        {
+            type: "info",
+            text: (
+                <p>
+                    Depending on the current position range and price, your
+                    input amounts are automatically adjusted to nearest
+                    required amounts. If you have insufficient tokens, you
+                    can acquire the required tokens on{" "}
+                    <a
+                        href="https://avnu.fi"
+                        target="_blank"
+                        rel="noopener noreferrer"
+                    >
+                        Avnu
+                    </a>
+                </p>
+            ),
+            tab: "deposit"
+        },
+        {
+            type: "info",
+            text: (
+                <>
+                    Depending on the current position range and price, you
+                    may receive both of the tokens or one of the tokens
+                    depending on the price
+                </>
+            ),
+            tab: "withdraw"
+        }
+    ],
+    tags: [StrategyTag.AUTOMATED_LP]
+  },
   faqs: getLSTFAQs("xSTRK"),
   points: [{
-    multiplier: 1, 
+    multiplier: 15,
     logo: 'https://endur.fi/favicon.ico',
     toolTip: "This strategy holds xSTRK and STRK tokens. Earn 1x Endur points on your xSTRK portion of Liquidity. STRK portion will earn Endur's DEX Bonus points. Points can be found on endur.fi.",
   }],
   contractDetails: [],
-  investmentSteps: []
+  investmentSteps: [],
+  tags: [StrategyTag.AUTOMATED_LP],
+  security: {
+    auditStatus: AuditStatus.AUDITED,
+    sourceCode: {
+      type: SourceCodeType.OPEN_SOURCE,
+      contractLink: "https://github.com/trovesfi/troves-contracts",
+    },
+    accessControl: {
+      type: AccessControlType.ROLE_BASED_ACCESS,
+      addresses: [MY_ACCESS_CONTROL.address],
+    },
+  },
+  redemptionInfo: {
+    instantWithdrawalVault: InstantWithdrawalVault.YES,
+    redemptionsInfo: [],
+    alerts: [],
+  },
+  usualTimeToEarnings: null,
+  usualTimeToEarningsDescription: null,
 };
 
-const lstStrategies: IStrategyMetadata<CLVaultStrategySettings>[] = [
-  xSTRKSTRK,
-  {
-    ...xSTRKSTRK,
-    name: "Ekubo xWBTC/WBTC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x2ea99b4971d3c277fa4a9b4beb7d4d7d169e683393a29eef263d5d57b4380a"
-    ),
-    launchBlock: 2338309,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "xWBTC")!,
-    ],
-    additionalInfo: {
-      ...xSTRKSTRK.additionalInfo,
-      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
-      lstContract: Global.getDefaultTokens().find((t) => t.symbol === "xWBTC")!.address,
+// Helper to create common LST alerts
+const getLSTAlerts = () => [
+    {
+        tab: "deposit" as const,
+        text: (
+            <>
+                To acquire the LST, please visit{" "}
+                <a
+                    href="https://app.endur.fi"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                >
+                    endur.fi
+                </a>
+            </>
+        ),
+        type: "info" as const
     },
-    faqs: getLSTFAQs("xWBTC"),
-    points: [],
-    contractDetails: [],
-    investmentSteps: []
-  },
-  {
-    ...xSTRKSTRK,
-    name: "Ekubo xtBTC/tBTC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x785dc3dfc4e80ef2690a99512481e3ed3a5266180adda5a47e856245d68a4af"
-    ),
-    launchBlock: 2415667,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "xtBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "tBTC")!,
-    ],
-    additionalInfo: {
-      ...xSTRKSTRK.additionalInfo,
-      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "tBTC")!,
-      lstContract: Global.getDefaultTokens().find((t) => t.symbol === "xtBTC")!.address,
+    {
+        type: "info" as const,
+        text: (
+            <p>
+                Depending on the current position range and price, your input
+                amounts are automatically adjusted to nearest required amounts.
+                If you have insufficient tokens, you can acquire the required
+                tokens on{" "}
+                <a
+                    href="https://avnu.fi"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                >
+                    Avnu
+                </a>
+            </p>
+        ),
+        tab: "deposit" as const
     },
-    faqs: getLSTFAQs("xtBTC"),
-    points: [],
-    contractDetails: [],
-    investmentSteps: []
-  },
-  {
+    {
+        type: "info" as const,
+        text: (
+            <>
+                Depending on the current position range and price, you may
+                receive both of the tokens or one of the tokens depending on the
+                price
+            </>
+        ),
+        tab: "withdraw" as const
+    }
+];
+
+// Helper to create LST strategy settings
+const createLSTSettings = (quoteTokenSymbol: string) => ({
+    ...xSTRKSTRK.settings,
+    isAudited: true,
+    liveStatus: StrategyLiveStatus.ACTIVE,
+    isInstantWithdrawal: true,
+    hideNetEarnings: true,
+    isTransactionHistDisabled: true,
+    quoteToken: Global.getDefaultTokens().find(
+        (t) => t.symbol === quoteTokenSymbol
+    )!,
+    alerts: getLSTAlerts(),
+    tags: [StrategyTag.AUTOMATED_LP] as StrategyTag[],
+});
+
+// Helper to create an LST strategy
+const createLSTStrategy = (params: {
+    id: string;
+    name: string;
+    address: string;
+    launchBlock: number;
+    depositToken0Symbol: string;
+    depositToken1Symbol: string;
+    quoteTokenSymbol: string;
+    lstSymbol: string;
+    lstContractAddress?: string;
+}): IStrategyMetadata<CLVaultStrategySettings> => ({
     ...xSTRKSTRK,
-    name: "Ekubo xsBTC/solvBTC",
+    id: params.id,
+    name: params.name,
     description: <></>,
-    address: ContractAddr.from(
-      "0x3af1c7faa7c464cf2c494e988972ad1939f1103dbfb6e47e9bf0c47e49b14ef"
-    ),
-    launchBlock: 2344809,
     // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "xsBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "solvBTC")!,
-    ],
-    additionalInfo: {
-      ...xSTRKSTRK.additionalInfo,
-      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "solvBTC")!,
-      lstContract: Global.getDefaultTokens().find((t) => t.symbol === "xsBTC")!.address,
+    address: ContractAddr.from(params.address),
+    launchBlock: params.launchBlock,
+    vaultType: {
+      type: vaultType,
+      description: vaultTypeDescription
     },
-    faqs: getLSTFAQs("xsBTC"),
-    points: [],
-    contractDetails: [],
-    investmentSteps: []
-  },
-  {
-    ...xSTRKSTRK,
-    name: "Ekubo xLBTC/LBTC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x314c4653ab1aa01f5465773cb879f525d7e369a137bc3ae084761aee99a1712"
-    ),
-    launchBlock: 2412442,
-    // must be same order as poolKey token0 and token1
     depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "LBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "xLBTC")!,
+        Global.getDefaultTokens().find(
+            (t) => t.symbol === params.depositToken0Symbol
+        )!,
+        Global.getDefaultTokens().find((t) => t.symbol === params.depositToken1Symbol)!
     ],
+    realizedApyMethodology: "The realizedAPY is based on past 14 days performance by the vault",
     additionalInfo: {
-      ...xSTRKSTRK.additionalInfo,
-      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "LBTC")!,
-      lstContract: Global.getDefaultTokens().find((t) => t.symbol === "xLBTC")!.address,
+        ...xSTRKSTRK.additionalInfo,
+        quoteAsset: Global.getDefaultTokens().find(
+            (t) => t.symbol === params.quoteTokenSymbol
+        )!,
+        lstContract: params.lstContractAddress
+            ? ContractAddr.from(params.lstContractAddress)
+            : Global.getDefaultTokens().find((t) => t.symbol === params.lstSymbol)!
+                  .address
     },
-    faqs: getLSTFAQs("xLBTC"),
+    settings: createLSTSettings(params.quoteTokenSymbol),
+    faqs: getLSTFAQs(params.lstSymbol),
     points: [],
     contractDetails: [],
-    investmentSteps: []
-  }
+    investmentSteps: [],
+    tags: params.id.toLowerCase().includes('btc') ? [StrategyTag.BTC, StrategyTag.AUTOMATED_LP] : [StrategyTag.AUTOMATED_LP]
+});
+
+const lstStrategies: IStrategyMetadata<CLVaultStrategySettings>[] = [
+    xSTRKSTRK,
+    createLSTStrategy({
+        id: "ekubo_cl_xstrkbtcstrkbtc",
+        name: "Ekubo xstrkBTC/strkBTC",
+        address: "0x03d1d1932ef6882d4acf763dd0430f4abed3e2a9da28e028f1e2e8dd934b8bf7",
+        launchBlock: 9651140,
+        depositToken0Symbol: "xstrkBTC",
+        depositToken1Symbol: "strkBTC",
+        quoteTokenSymbol: "strkBTC",
+        lstSymbol: "xstrkBTC",
+    }),
+    createLSTStrategy({
+        id: "ekubo_cl_xwbtcwbtc",
+        name: "Ekubo xWBTC/WBTC",
+        address: "0x2ea99b4971d3c277fa4a9b4beb7d4d7d169e683393a29eef263d5d57b4380a",
+        launchBlock: 2338309,
+        depositToken0Symbol: "WBTC",
+        depositToken1Symbol: "xWBTC",
+        quoteTokenSymbol: "WBTC",
+        lstSymbol: "xWBTC",
+    }),
+    createLSTStrategy({
+        id: "ekubo_cl_xtbtctbtc",
+        name: "Ekubo xtBTC/tBTC",
+        address: "0x785dc3dfc4e80ef2690a99512481e3ed3a5266180adda5a47e856245d68a4af",
+        launchBlock: 2415667,
+        depositToken0Symbol: "xtBTC",
+        depositToken1Symbol: "tBTC",
+        quoteTokenSymbol: "tBTC",
+        lstSymbol: "xtBTC",
+    }),
+    createLSTStrategy({
+        id: "ekubo_cl_xsbtcsolvbtc",
+        name: "Ekubo xsBTC/solvBTC",
+        address: "0x3af1c7faa7c464cf2c494e988972ad1939f1103dbfb6e47e9bf0c47e49b14ef",
+        launchBlock: 2344809,
+        depositToken0Symbol: "xsBTC",
+        depositToken1Symbol: "solvBTC",
+        quoteTokenSymbol: "solvBTC",
+        lstSymbol: "xsBTC",
+    }),
+    createLSTStrategy({
+        id: "ekubo_cl_xlbtclbtc",
+        name: "Ekubo xLBTC/LBTC",
+        address: "0x314c4653ab1aa01f5465773cb879f525d7e369a137bc3ae084761aee99a1712",
+        launchBlock: 2412442,
+        depositToken0Symbol: "LBTC",
+        depositToken1Symbol: "xLBTC",
+        quoteTokenSymbol: "LBTC",
+        lstSymbol: "xLBTC",
+    })
 ];
 
-const ETHUSDCRe7Strategy: IStrategyMetadata<CLVaultStrategySettings> = {
-  ...xSTRKSTRK,
-  name: "Ekubo ETH/USDC",
-  description: <></>,
-  address: ContractAddr.from(
-    "0x160d8fa4569ef6a12e6bf47cb943d7b5ebba8a41a69a14c1d943050ba5ff947"
-  ),
-  launchBlock: 1504232,
-  // must be same order as poolKey token0 and token1
-  depositTokens: [
-    Global.getDefaultTokens().find((t) => t.symbol === "ETH")!,
-    Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-  ],
-  apyMethodology:
-  "Annualized fee APY, calculated as fees earned in the last 7d divided by TVL",
-  additionalInfo: {
-    newBounds: "Managed by Re7",
-    truePrice: 1,
-    feeBps: 1000,
-    rebalanceConditions: {
-      customShouldRebalance: async (currentPrice: number) =>
-        currentPrice > 0.99 && currentPrice < 1.01,
-      minWaitHours: 6,
-      direction: "any"
+const getRe7Alerts = () => [
+    {
+        type: "info" as const,
+        text: (
+            <p>
+                Depending on the current position range and price, your input
+                amounts are automatically adjusted to nearest required amounts.
+                If you have insufficient tokens, you can acquire the required
+                tokens on{" "}
+                <a
+                    href="https://avnu.fi"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                >
+                    Avnu
+                </a>
+            </p>
+        ),
+        tab: "deposit" as const
     },
-    quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "USDC")!,
-  },
-  faqs: [
+    {
+        type: "info" as const,
+        text: (
+            <>
+                Depending on the current position range and price, you may
+                receive both of the tokens or one of the tokens depending on the
+                price
+            </>
+        ),
+        tab: "withdraw" as const
+    }
+];
+
+// Helper to create Re7 strategy settings
+const createRe7Settings = (quoteTokenSymbol: string, isBTC: boolean, isDeprecated: boolean) => ({
+    ...xSTRKSTRK.settings,
+    isAudited: true,
+    liveStatus: isDeprecated ? StrategyLiveStatus.DEPRECATED : StrategyLiveStatus.ACTIVE,
+    isInstantWithdrawal: true,
+    hideNetEarnings: true,
+    isTransactionHistDisabled: false,
+    quoteToken: Global.getDefaultTokens().find(
+        (t) => t.symbol === quoteTokenSymbol
+    )!,
+    alerts: getRe7Alerts(),
+    tags: isBTC ? [StrategyTag.BTC, StrategyTag.AUTOMATED_LP] : [StrategyTag.AUTOMATED_LP] as StrategyTag[]
+});
+
+// Helper to create Re7 FAQs
+const getRe7FAQs = () => [
     ...faqs,
     {
-      question: "Who is the curator of this strategy?",
-      answer:
-        <div>Re7 Labs is the curator of this strategy. Re7 Labs is a well-known Web3 asset management firm. This strategy is completely managed by them, including ownership of the vault. Troves is developer of the smart contracts and maintains infrastructure to help users access these strategies. You can find more information about them on their website <a href='https://www.re7labs.xyz' style={{textDecoration: "underline", marginLeft: "2px"}} target="_blank">here</a>.</div>
+        question: "Who is the curator of this strategy?",
+        answer: (
+            <div>
+                Re7 Labs is the curator of this strategy. Re7 Labs is a
+                well-known Web3 asset management firm. This strategy is
+                completely managed by them, including ownership of the vault.
+                Troves is developer of the smart contracts and maintains
+                infrastructure to help users access these strategies. You can
+                find more information about them on their website{" "}
+                <a
+                    href="https://www.re7labs.xyz"
+                    style={{
+                        textDecoration: "underline",
+                        marginLeft: "2px"
+                    }}
+                    target="_blank"
+                >
+                    here
+                </a>
+                .
+            </div>
+        )
     },
     {
-      question: "How is the APY calculated?",
-      answer:
-        <div>It's an annualized fee APY, calculated as fees earned in the last 24h divided by TVL. Factors like impermanent loss are not considered.</div>
-    },
-  ],
-  risk: highRisk,
-  points: [],
-  curator: { name: "Re7 Labs", logo: "https://www.re7labs.xyz/favicon.ico" }
+        question: "How is the APY calculated?",
+        answer: (
+            <div>
+                It's an annualized fee APY, calculated as fees earned in the
+                last 24h divided by TVL. Factors like impermanent loss are not
+                considered.
+            </div>
+        )
+    }
+];
+
+// Helper to create a Re7 strategy
+const createRe7Strategy = (
+    id: string,
+    name: string,
+    address: string,
+    launchBlock: number,
+    depositToken0Symbol: string,
+    depositToken1Symbol: string,
+    quoteTokenSymbol: string,
+    risk:
+        | typeof highRisk
+        | typeof mediumRisk
+        | { riskFactor: RiskFactor[]; netRisk: number; notARisks: RiskType[] },
+    isBTC: boolean
+): IStrategyMetadata<CLVaultStrategySettings> => {
+    const isDeprecated = name.toLowerCase().includes('usdc.e');
+    return {
+        ...xSTRKSTRK,
+        id,
+        name,
+        description: <></>,
+        address: ContractAddr.from(address),
+        launchBlock,
+        vaultType: {
+          type: vaultType,
+          description: vaultTypeDescription
+        },
+        depositTokens: [
+            Global.getDefaultTokens().find(
+                (t) => t.symbol === depositToken0Symbol
+            )!,
+            Global.getDefaultTokens().find((t) => t.symbol === depositToken1Symbol)!
+        ],
+        apyMethodology:
+            "Annualized fee APY, calculated as fees earned in the last 7d divided by TVL",
+        additionalInfo: {
+            newBounds: "Managed by Re7",
+            truePrice: 1,
+            feeBps: 1000,
+            rebalanceConditions: {
+                customShouldRebalance: async (currentPrice: number) =>
+                    currentPrice > 0.99 && currentPrice < 1.01,
+                minWaitHours: 6,
+                direction: "any" as const
+            },
+            quoteAsset: Global.getDefaultTokens().find(
+                (t) => t.symbol === quoteTokenSymbol
+            )!
+        },
+        settings: createRe7Settings(quoteTokenSymbol, isBTC, isDeprecated),
+        faqs: getRe7FAQs(),
+        risk,
+        points: [],
+        curator: { name: "Re7 Labs", logo: "https://www.re7labs.xyz/favicon.ico" },
+        tags: isBTC ? [StrategyTag.BTC, StrategyTag.AUTOMATED_LP] : [StrategyTag.AUTOMATED_LP] as StrategyTag[],
+        discontinuationInfo: isDeprecated ? {
+            info: "This strategy has been deprecated and is no longer accepting new deposits."
+        } : undefined,
+        security: {
+          ...xSTRKSTRK.security,
+          accessControl: {
+            ...xSTRKSTRK.security.accessControl,
+            addresses: [ContractAddr.from("0x707bf89863473548fb2844c9f3f96d83fe2394453259035a5791e4b1490642")],
+          },
+        },
+    };
+};
+
+const ETHUSDCRe7Strategy = createRe7Strategy(
+    "ekubo_cl_ethusdc",
+    "Ekubo ETH/USDC.e",
+    "0x160d8fa4569ef6a12e6bf47cb943d7b5ebba8a41a69a14c1d943050ba5ff947",
+    1504232,
+    "ETH",
+    "USDC.e",
+    "USDC.e",
+    highRisk,
+    false // isBTC
+);
+
+const stableCoinRisk = {
+    riskFactor: _stableCoinPoolRiskFactors,
+    netRisk:
+        _stableCoinPoolRiskFactors.reduce(
+            (acc, curr) => acc + curr.value * curr.weight,
+            0
+        ) /
+        _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(_stableCoinPoolRiskFactors)
 };
 
 const RE7Strategies: IStrategyMetadata<CLVaultStrategySettings>[] = [
-  ETHUSDCRe7Strategy,
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo USDC/USDT",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x3a4f8debaf12af97bb911099bc011d63d6c208d4c5ba8e15d7f437785b0aaa2"
+    ETHUSDCRe7Strategy,
+    createRe7Strategy(
+        "ekubo_cl_usdcusdt",
+        "Ekubo USDC.e/USDT",
+        "0x3a4f8debaf12af97bb911099bc011d63d6c208d4c5ba8e15d7f437785b0aaa2",
+        1506139,
+        "USDC.e",
+        "USDT",
+        "USDC.e",
+        stableCoinRisk,
+        false // isBTC
     ),
-    launchBlock: 1506139,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "USDC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "USDT")!
-    ],
-    risk: {
-      riskFactor: _stableCoinPoolRiskFactors,
-      netRisk:
-      _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
-      _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
-      notARisks: getNoRiskTags(_stableCoinPoolRiskFactors),
-    }
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo STRK/USDC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x351b36d0d9d8b40010658825adeeddb1397436cd41acd0ff6c6e23aaa8b5b30"
+    createRe7Strategy(
+        "ekubo_cl_strkusdc",
+        "Ekubo STRK/USDC.e",
+        "0x351b36d0d9d8b40010658825adeeddb1397436cd41acd0ff6c6e23aaa8b5b30",
+        1504079,
+        "STRK",
+        "USDC.e",
+        "USDC.e",
+        highRisk,
+        false // isBTC
     ),
-    launchBlock: 1504079,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-    ],
-    risk: highRisk,
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo STRK/ETH",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x4ce3024b0ee879009112d7b0e073f8a87153dd35b029347d4247ffe48d28f51"
+    createRe7Strategy(
+        "ekubo_cl_strketh",
+        "Ekubo STRK/ETH",
+        "0x4ce3024b0ee879009112d7b0e073f8a87153dd35b029347d4247ffe48d28f51",
+        1504149,
+        "STRK",
+        "ETH",
+        "USDC",
+        highRisk,
+        false // isBTC
     ),
-    launchBlock: 1504149,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "STRK")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "ETH")!
-    ],
-    risk: highRisk,
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo WBTC/USDC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x2bcaef2eb7706875a5fdc6853dd961a0590f850bc3a031c59887189b5e84ba1"
+    createRe7Strategy(
+        "ekubo_cl_wbtcusdc",
+        "Ekubo WBTC/USDC.e",
+        "0x2bcaef2eb7706875a5fdc6853dd961a0590f850bc3a031c59887189b5e84ba1",
+        1506144,
+        "WBTC",
+        "USDC.e",
+        "USDC.e",
+        mediumRisk,
+        true // isBTC
     ),
-    launchBlock: 1506144,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-    ],
-    risk: mediumRisk,
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo tBTC/USDC",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x4aad891a2d4432fba06b6558631bb13f6bbd7f6f33ab8c3111e344889ea4456"
+    // createRe7Strategy(
+    //     "ekubo_cl_tbtcusdce",
+    //     "Ekubo tBTC/USDC.e",
+    //     "0x4aad891a2d4432fba06b6558631bb13f6bbd7f6f33ab8c3111e344889ea4456",
+    //     1501764,
+    //     "tBTC",
+    //     "USDC.e",
+    //     "USDC.e",
+    //     mediumRisk,
+    // ),
+    createRe7Strategy(
+        "ekubo_cl_wbtceth",
+        "Ekubo WBTC/ETH",
+        "0x1c9232b8186d9317652f05055615f18a120c2ad9e5ee96c39e031c257fb945b",
+        1506145,
+        "WBTC",
+        "ETH",
+        "USDC",
+        mediumRisk,
+        true // isBTC
     ),
-    launchBlock: 1501764,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "tBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "USDC")!
-    ],
-    risk: mediumRisk,
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo WBTC/ETH",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x1c9232b8186d9317652f05055615f18a120c2ad9e5ee96c39e031c257fb945b"
+    createRe7Strategy(
+        "ekubo_cl_wbtcstrk",
+        "Ekubo WBTC/STRK",
+        "0x1248e385c23a929a015ec298a26560fa7745bbd6e41a886550e337b02714b1b",
+        1506147,
+        "WBTC",
+        "STRK",
+        "USDC",
+        highRisk,
+        true // isBTC
     ),
-    launchBlock: 1506145,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "ETH")!
-    ],
-    risk: mediumRisk,
-  },
-  {
-    ...ETHUSDCRe7Strategy,
-    name: "Ekubo WBTC/STRK",
-    description: <></>,
-    address: ContractAddr.from(
-      "0x1248e385c23a929a015ec298a26560fa7745bbd6e41a886550e337b02714b1b"
+    createRe7Strategy(
+        "ekubo_cl_usdc_v2usdt",
+        "Ekubo USDC/USDT",
+        "0x5203a08b471e46bf33990ac83aff577bbe5a5d789e61de2c6531e3c4773d1c9",
+        3998018,
+        "USDC",
+        "USDT",
+        "USDC",
+        stableCoinRisk,
+        false // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_ethusdc_v2",
+        "Ekubo ETH/USDC",
+        "0x4d00c7423b3c0fae3640f6099ac97acbfd8708f099e09bfe3a7a6a680399228",
+        3998025,
+        "USDC",
+        "ETH",
+        "USDC",
+        highRisk,
+        false // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_strkusdc_v2",
+        "Ekubo STRK/USDC",
+        "0x4de22bd0a8eb4d0a18736e66dd36d20ba50bc106346bbfac3dbeaac1ab37ce1",
+        3998030,
+        "USDC",
+        "STRK",
+        "USDC",
+        highRisk,
+        false // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_wbtcusdc_v2",
+        "Ekubo WBTC/USDC",
+        "0x76101c3b80af1103c9c6d541ca627f61b5ae7ae79d7fce96ccdf7bdb648450d",
+        3998034,
+        "USDC",
+        "WBTC",
+        "USDC",
+        mediumRisk,
+        true // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_strkbtcusdc",
+        "Ekubo strkBTC/USDC",
+        "0x02dfe5af1665a7adf549008161c818eb18dcf89fc9518ab812294f2b691b2845",
+        9650986,
+        "USDC",
+        "strkBTC",
+        "USDC",
+        mediumRisk,
+        true // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_strkbtcstrk",
+        "Ekubo strkBTC/STRK",
+        "0x04784e62a4847484528ba65f500b37a9347e88632e90d866e213f2c2651be828",
+        9650592,
+        "STRK",
+        "strkBTC",
+        "USDC",
+        mediumRisk,
+        true // isBTC
+    ),
+    createRe7Strategy(
+        "ekubo_cl_strkbtceth",
+        "Ekubo strkBTC/ETH",
+        "0x07118ecd7dece83462b0ac8302c682fb17c7e18b0be13d81867c5bf3f80933ef",
+        9650986,
+        "ETH",
+        "strkBTC",
+        "USDC",
+        mediumRisk,
+        true // isBTC
+    ),
+    // wbtc/strkBTC
+    createRe7Strategy(
+        "ekubo_cl_wbtcstrkbtc",
+        "Ekubo WBTC/strkBTC",
+        "0x07e927222730899442b2438bfd6218ff8ac44bd7a3420646fca359b8392e42c1",
+        9650986,
+        "WBTC",
+        "strkBTC",
+        "strkBTC",
+        stableCoinRisk,
+        true // isBTC
     ),
-    launchBlock: 1506147,
-    // must be same order as poolKey token0 and token1
-    depositTokens: [
-      Global.getDefaultTokens().find((t) => t.symbol === "WBTC")!,
-      Global.getDefaultTokens().find((t) => t.symbol === "STRK")!
-    ],
-    risk: highRisk,
-  }
 ];
 
 /**
@@ -2375,7 +3071,7 @@ EkuboCLVaultStrategies.forEach((s) => {
       address: s.address,
       name: "Vault",
       sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/cl_vault"
-    }, 
+    },
     // ...COMMON_CONTRACTS
   ];
   // set docs link
@@ -2419,4 +3115,4 @@ EkuboCLVaultStrategies.forEach((s) => {
     "Monitor and Rebalance position to optimize yield",
     "Harvest and re-invest any rewards every week (Auto-compound)",
   ]
-});
+});