@strkfarm/sdk 1.1.70 → 1.1.71

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -17,6 +17,8 @@ import { findMaxInputWithSlippage } from "@/utils/math-utils";
 export interface HyperLSTStrategySettings extends UniversalStrategySettings {
   borrowable_assets: TokenInfo[];
   underlyingToken: TokenInfo;
+  defaultPoolId: ContractAddr;
+  altSupportedPoolIds: ContractAddr[];
 }
 
 export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
@@ -37,7 +39,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   }
 
   asset() {
-    return this.getVesuSameTokenAdapter().config.collateral;
+    return this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId).config.collateral;
   }
 
   getTag() {
@@ -45,8 +47,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   }
 
   // Vesu adapter with LST and base token match
-  getVesuSameTokenAdapter() {
-    const baseAdapter = this.getAdapter(getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, this.metadata.additionalInfo.underlyingToken.symbol)) as VesuAdapter;
+  getVesuSameTokenAdapter(poolId: ContractAddr) {
+    const baseAdapter = this.getAdapter(getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, this.metadata.additionalInfo.underlyingToken.symbol, poolId.toString())) as VesuAdapter;
     baseAdapter.networkConfig = this.config;
     baseAdapter.pricer = this.pricer;
     return baseAdapter;
@@ -56,18 +58,20 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   // todo support lending assets of underlying as well (like if xSTRK looping is not viable, simply supply STRK)
   getVesuAdapters() {
     const adapters: VesuAdapter[] = [];
-    const baseAdapter = this.getVesuSameTokenAdapter();
-    for (const asset of this.metadata.additionalInfo.borrowable_assets) {
-      const vesuAdapter1 = new VesuAdapter({
-        poolId: baseAdapter.config.poolId,
-        collateral: this.asset(),
-        debt: asset,
-        vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
-        id: ''
-      })
-      vesuAdapter1.pricer = this.pricer;
-      vesuAdapter1.networkConfig = this.config;
-      adapters.push(vesuAdapter1);
+    for (const poolId of [this.metadata.additionalInfo.defaultPoolId, ...this.metadata.additionalInfo.altSupportedPoolIds]) {
+      const baseAdapter = this.getVesuSameTokenAdapter(poolId);
+      for (const asset of this.metadata.additionalInfo.borrowable_assets) {
+        const vesuAdapter1 = new VesuAdapter({
+          poolId: baseAdapter.config.poolId,
+          collateral: this.asset(),
+          debt: asset,
+          vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
+          id: ''
+        })
+        vesuAdapter1.pricer = this.pricer;
+        vesuAdapter1.networkConfig = this.config;
+        adapters.push(vesuAdapter1);
+      }
     }
     return adapters;
   }
@@ -223,7 +227,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       const debtAmountInLST = debtAmount.abs().dividedBy(lstDEXPrice);
       const calls = await this.getVesuMultiplyCall({
         isDeposit: false,
-        leg1DepositAmount: debtAmountInLST
+        leg1DepositAmount: debtAmountInLST,
+        poolId: vesuAdapter.config.poolId
       })
       assert(calls.length == 1, `Expected 1 call for unwind, got ${calls.length}`);
       return calls[0];
@@ -234,7 +239,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     const manageCall0 = manage0Info.callConstructor({
       amount: newDepositAmount
     });
-    const STEP1 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
+    const STEP1 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol, vesuAdapter.config.poolId.toString());
     const manage1Info = this.getProofs<VesuModifyPositionCallParams>(STEP1);
     const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
         collateralAmount: newDepositAmount,
@@ -300,7 +305,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
           amount: minAmount
         });
        
-        const STEP5 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
+        const STEP5 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol, vesuAdapter.config.poolId.toString());
         const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP5);
         const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
           collateralAmount: minAmount,
@@ -428,10 +433,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   async getVesuMultiplyCall(params: {
     isDeposit: boolean,
     leg1DepositAmount: Web3Number,
-    maxEkuboPriceImpact?: number
+    maxEkuboPriceImpact?: number,
+    poolId: ContractAddr
   }) {
     const maxEkuboPriceImpact = params.maxEkuboPriceImpact || 0.01;
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(params.poolId);
     const legLTV = await vesuAdapter1.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
 
@@ -508,21 +514,24 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       debtAmount,
       lstDexPriceInUnderlying: dexPrice,
       isIncrease: debtAmount.greaterThan(0),
-      maxEkuboPriceImpact
+      maxEkuboPriceImpact,
+      poolId: params.poolId
     });
   }
 
   getLSTUnderlyingTokenInfo() {
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
     return vesuAdapter1.config.debt;
   }
 
   async getMaxBorrowableAmount(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
     const vesuAdapters = this.getVesuAdapters();
     let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
-    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo}[] = [];
+    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo, ltv: number}[] = [];
     for (const vesuAdapter of vesuAdapters) {
-      maxBorrowables.push(await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, params.isAPYComputation));
+      const output = await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, params.isAPYComputation);
+      const ltv = await vesuAdapter.getLTVConfig(this.config);
+      maxBorrowables.push({...output, ltv});
     }
     maxBorrowables.sort((a, b) => b.amount.toNumber() - a.amount.toNumber());
     netMaxBorrowableAmount = maxBorrowables.reduce((acc, curr) => acc.plus(curr.amount), Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals));
@@ -550,10 +559,16 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   async getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean) {
     const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
     const maxInterestRate = lstAPY * 0.8;
-    const maxBorrowableAmount = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
+    const {maxDebtToHave: maxBorrowableAmount, currentDebt} = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
     const debtCap = await vesuAdapter.getDebtCap(this.config);
 
-    const maxBorrowable = maxBorrowableAmount.minimum(debtCap).multipliedBy(0.999);
+    if (currentDebt.gte(debtCap)) {
+      return {amount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), dexSwappableAmount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), maxBorrowableAmount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), borrowableAsset: vesuAdapter.config.debt};
+    }
+
+    const availableToBorrow = debtCap.minus(currentDebt);
+
+    const maxBorrowable = maxBorrowableAmount.minimum(availableToBorrow).multipliedBy(0.999);
     // Dont compute precise max swappable for APY computation
     if (vesuAdapter.config.debt.address.eq(this.getLSTUnderlyingTokenInfo().address) || isAPYComputation) {
       return {amount: maxBorrowable, dexSwappableAmount: maxBorrowable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
@@ -579,7 +594,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
    */
   async getLSTAPR(_address: ContractAddr): Promise<number> {
     try {
-      const vesuAdapter1 = this.getVesuSameTokenAdapter();
+      const vesuAdapter1 = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
       const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
       if (!apr) {
         throw new Error('Failed to get LST APR');
@@ -619,32 +634,25 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
   async maxNewDeposits(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
     const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
-    
+    let numerator = 0;
+
     let ltv: number | undefined = undefined;
     for (let adapter of this.getVesuAdapters()) {
-      const maxBorrowableAmount = maxBorrowableAmounts.maxBorrowables.find(b => b.borrowableAsset.address.eq(adapter.config.debt.address))?.amount;
-      if (!maxBorrowableAmount) {
+      const maxBorrowableAmountInfo = maxBorrowableAmounts.maxBorrowables.find(b => b.borrowableAsset.address.eq(adapter.config.debt.address));
+      if (!maxBorrowableAmountInfo || !maxBorrowableAmountInfo?.amount) {
         throw new Error(`Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`);
       }
-      const maxLTV = await adapter.getLTVConfig(this.config);
-      if (!ltv) {
-        ltv = maxLTV;
-      } else if (ltv != maxLTV) {
-        throw new Error(`LTV mismatch for adapter: ${adapter.config.debt.symbol}`);
-      }
-    }
-    if (!ltv) {
-      throw new Error('LTV not found');
+
+      numerator += this.metadata.additionalInfo.targetHealthFactor * maxBorrowableAmountInfo.amount.toNumber() / maxBorrowableAmountInfo.ltv;
     }
-    // for simplicity, we assume 1 underlying = 1 LST
-    const numerator = this.metadata.additionalInfo.targetHealthFactor * maxBorrowableAmounts.netMaxBorrowableAmount.toNumber() / (ltv) 
+
     return  numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
   }
 
   // todo revisit cases where 0th adapters is used
   protected async getUnusedBalanceAPY() {
     const unusedBalance = await this.getUnusedBalance();
-    const vesuAdapter = this.getVesuSameTokenAdapter();
+    const vesuAdapter = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
     const underlying = vesuAdapter.config.debt;
     const lstAPY = await this.getLSTAPR(underlying.address);
     return {
@@ -653,7 +661,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   }
 
   async getLSTExchangeRate() {
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
     const lstTokenInfo = vesuAdapter1.config.collateral;
     const lstABI = new Contract({
       abi: ERC4626Abi,
@@ -676,12 +684,13 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     debtAmount: Web3Number,
     lstDexPriceInUnderlying: number,
     isIncrease: boolean,
-    maxEkuboPriceImpact: number
+    maxEkuboPriceImpact: number,
+    poolId: ContractAddr
   }): Promise<Call[]> {
     logger.verbose(`${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`);
     assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
 
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(params.poolId);
     const lstTokenInfo = this.asset();
     const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
 
@@ -697,7 +706,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
     // approve token
     if (params.marginAmount.greaterThan(0)) {
-      const STEP1_ID = LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE;
+      const STEP1_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE);
       const manage1Info = this.getProofs<ApproveCallParams>(STEP1_ID);
       const depositAmount = params.marginAmount;
       const manageCall1 = manage1Info.callConstructor({
@@ -748,14 +757,14 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     // }
     maxUsedCollateral = maxUsedCollateralInLST; // in any case, we are ok with this, bcz the BTC LST spread shouldnt be high
 
-    const STEP2_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON;
+    const STEP2_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON);
     const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
     const manageCall2 = manage2Info.callConstructor({
       delegation: true
     });
 
     // deposit and borrow or repay and withdraw
-    const STEP3_ID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, vesuAdapter1.config.debt.symbol);
+    const STEP3_ID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, vesuAdapter1.config.debt.symbol, vesuAdapter1.config.poolId.toString());
     const manage3Info = this.getProofs<VesuMultiplyCallParams>(STEP3_ID);
     const multiplyParams: VesuMultiplyCallParams = params.isIncrease ? {
       isIncrease: true,
@@ -784,7 +793,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     const manageCall3 = manage3Info.callConstructor(multiplyParams);
 
     // switch delegation off
-    const STEP4_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF;
+    const STEP4_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF);
     const manage4Info = this.getProofs<VesuModifyDelegationCallParams>(STEP4_ID);
     const manageCall4 = manage4Info.callConstructor({
       delegation: false
@@ -864,28 +873,75 @@ function getAvnuManageIDs(baseID: LST_MULTIPLIER_MANAGE_IDS, debtTokenSymbol: st
   return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
 }
 
-function getVesuLegId(baseID: string, debtTokenSymbol: string) {
-  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
+function getVesuGenericLegId(poolId: string, action: string) {
+  return `${action}_${poolId.slice(-4).toLowerCase()}`;
 }
 
-function getLooperSettings(
+function getVesuLegId(baseID: string, debtTokenSymbol: string, poolId: string) {
+  return `${baseID}_${debtTokenSymbol.toLowerCase()}_${poolId.slice(-4).toLowerCase()}`;
+}
+
+function addVesuLeaves(
+  poolId: ContractAddr,
   lstSymbol: string,
   underlyingSymbol: string,
   vaultSettings: HyperLSTStrategySettings,
-  pool1: ContractAddr,
+  commonAdapter: CommonAdapter,
 ) {
-  vaultSettings.leafAdapters = [];
-
   const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
   const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
 
   const vesuAdapterLST = new VesuAdapter({
-    poolId: pool1,
+    poolId: poolId,
     collateral: lstToken,
     debt: underlyingToken,
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol)
-  })
+    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol, poolId.toString())
+  });
+
+  // Useful for returning adapter class objects that can compute
+  // certain things for us (e.g. positions, hfs)
+  vaultSettings.adapters.push(...[{
+    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol, poolId.toString()),
+    adapter: vesuAdapterLST
+  }]);
+
+  // avnu multiply
+  const { isV2, addr: _ } = getVesuSingletonAddress(poolId);
+
+  // vesu multiply looping
+  const VESU_MULTIPLY = isV2 ? vesuAdapterLST.VESU_MULTIPLY : vesuAdapterLST.VESU_MULTIPLY_V1;
+
+  const leafIdApprove = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE);
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, leafIdApprove).bind(commonAdapter));
+  
+  const leafIdDelegationOn = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON);
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(leafIdDelegationOn).bind(vesuAdapterLST));
+  
+  const leafIdDelegationOff = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF);
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(leafIdDelegationOff).bind(vesuAdapterLST));
+
+  const multiplID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, underlyingToken.symbol, poolId.toString());
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter(multiplID).bind(vesuAdapterLST));
+ 
+  return vesuAdapterLST;
+}
+
+function getLooperSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  vaultSettings: HyperLSTStrategySettings,
+  defaultPoolId: ContractAddr,
+  altSupportedPoolIds: ContractAddr[] = []
+) {
+  vaultSettings.leafAdapters = [];
+  const pool1 = vaultSettings.defaultPoolId;
+  if (!pool1.eq(defaultPoolId)) {
+    throw new Error(`Dont include default pool id in supported pool ids`);
+  }
+
+  const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
+  const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
 
   const commonAdapter = new CommonAdapter({
     manager: vaultSettings.manager,
@@ -893,26 +949,20 @@ function getLooperSettings(
     id: '',
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
-  })
+  });
 
-  // Useful for returning adapter class objects that can compute
-  // certain things for us (e.g. positions, hfs)
+  // add common adapter to adapters
   vaultSettings.adapters.push(...[{
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol),
-    adapter: vesuAdapterLST
-  },{
     id: UNIVERSAL_ADAPTERS.COMMON,
     adapter: commonAdapter
-  }])
+  }]);
 
-  // avnu multiply
-  const { isV2, addr:poolAddr } = getVesuSingletonAddress(pool1);
-  // vesu multiply looping
-  const VESU_MULTIPLY = isV2 ? vesuAdapterLST.VESU_MULTIPLY : vesuAdapterLST.VESU_MULTIPLY_V1;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON).bind(vesuAdapterLST));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF).bind(vesuAdapterLST));
+  // add vesu leaves for default pool id
+  const vesuAdapterLST = addVesuLeaves(defaultPoolId, lstSymbol, underlyingSymbol, vaultSettings, commonAdapter);
 
+  // add vesu leaves for alt supported pool ids
+  altSupportedPoolIds.map(poolId => addVesuLeaves(poolId, lstSymbol, underlyingSymbol, vaultSettings, commonAdapter));
+  
   // approve lst once to avnu
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_WITHDRAW).bind(commonAdapter));
   for (let borrowableAsset of vaultSettings.borrowable_assets) {
@@ -931,14 +981,16 @@ function getLooperSettings(
       collateral: lstToken,
       debt: debtAsset,
       vaultAllocator: vaultSettings.vaultAllocator,
-      id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, debtAsset.symbol)
+      id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, debtAsset.symbol, pool1.toString())
     });
+    const { isV2, addr:poolAddr } = getVesuSingletonAddress(pool1);
     vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
     vaultSettings.leafAdapters.push(vesuAdapter.getModifyPosition.bind(vesuAdapter));
 
     // Vesu multiply
-    const multiplID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, debtAsset.symbol);
-    vaultSettings.leafAdapters.push(vesuAdapter.getMultiplyAdapter(multiplID).bind(vesuAdapter));
+    if (borrowableAsset.address.eq(underlyingToken.address)) {
+      continue; // already added in addVesuLeaves
+    }
   }
 
   
@@ -1033,6 +1085,8 @@ const hyperxSTRK: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'STRK'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
+  defaultPoolId: VesuPools.Re7xSTRK,
+  altSupportedPoolIds: [VesuPools.Prime],
 }
 
 const hyperxWBTC: HyperLSTStrategySettings = {
@@ -1047,6 +1101,8 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+  defaultPoolId: VesuPools.Re7xBTC,
+  altSupportedPoolIds: [],
 }
 
 const hyperxtBTC: HyperLSTStrategySettings = {
@@ -1061,6 +1117,8 @@ const hyperxtBTC: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'tBTC' || token.symbol === 'WBTC'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!,
+  defaultPoolId: VesuPools.Re7xBTC,
+  altSupportedPoolIds: [],
 }
 
 const hyperxsBTC: HyperLSTStrategySettings = {
@@ -1075,6 +1133,8 @@ const hyperxsBTC: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'solvBTC'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
+  defaultPoolId: VesuPools.Re7xBTC,
+  altSupportedPoolIds: [],
 }
 
 const hyperxLBTC: HyperLSTStrategySettings = {
@@ -1089,6 +1149,8 @@ const hyperxLBTC: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'LBTC'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
+  defaultPoolId: VesuPools.Re7xBTC,
+  altSupportedPoolIds: [],
 }
 
 function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
@@ -1109,7 +1171,7 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
     launchBlock: 0,
     type: 'Other',
     depositTokens: [Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!],
-    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, lstSymbol === 'xSTRK' ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
+    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, addresses.defaultPoolId, lstSymbol === 'xSTRK' ? [VesuPools.Prime] : []),
     risk: {
       riskFactor: _riskFactor,
       netRisk: