@strkfarm/sdk 1.1.34 → 1.1.36

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -14,6 +14,7 @@ import { ENDPOINTS } from "../constants";
 import VesuMultiplyAbi from '@/data/vesu-multiple.abi.json';
 import { EkuboPoolKey } from "../ekubo-cl-vault";
 import VesuPoolV2Abi from '@/data/vesu-pool-v2.abi.json';
+import VesuExtensionAbi from '@/data/vesu-extension.abi.json';
 
 interface VesuPoolsInfo { pools: any[]; isErrorPoolsAPI: boolean };
 
@@ -56,6 +57,23 @@ export interface VesuAdapterConfig {
   id: string
 }
 
+type InterestRateConfig = {
+  target_utilization: bigint;
+  zero_utilization_rate: bigint;
+  target_rate_percent: bigint;
+
+  min_target_utilization: bigint;
+  max_target_utilization: bigint;
+  rate_half_life: bigint;
+  min_full_utilization_rate: bigint;
+  max_full_utilization_rate: bigint;
+};
+
+const SCALE = BigInt(1e18);
+const UTILIZATION_SCALE = 100_000n;
+const UTILIZATION_SCALE_TO_SCALE = BigInt(1e13);
+
+
 export interface TokenAmount {
   token: ContractAddr,
   amount: Web3Number, // i129
@@ -217,6 +235,9 @@ export const VesuPools = {
   Re7xBTC: ContractAddr.from('0x3a8416bf20d036df5b1cf3447630a2e1cb04685f6b0c3a70ed7fb1473548ecf')
 }
 
+export const extensionMap: {[key: string]: ContractAddr} = {};
+extensionMap[VesuPools.Re7xSTRK.address] = ContractAddr.from('0x04e06e04b8d624d039aa1c3ca8e0aa9e21dc1ccba1d88d0d650837159e0ee054');
+
 export function getVesuSingletonAddress(vesuPool: ContractAddr) {
   if (vesuPool.eq(VesuPools.Genesis) ||
       vesuPool.eq(VesuPools.Re7xSTRK)) {
@@ -501,6 +522,67 @@ export class VesuAdapter extends BaseAdapter {
     }
   }
 
+  async getDebtCap(config: IConfig) {
+    const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
+    if (!isV2) {
+      const extensionAddr = extensionMap[this.config.poolId.address];
+      if (!extensionAddr) {
+        throw new Error('Extension address not found');
+      }
+      const extensionContract = new Contract({abi: VesuExtensionAbi, address: extensionAddr.address, providerOrAccount: config.provider});
+      const output: any = await extensionContract.call('debt_caps', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+      logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap debt_cap: ${output.toString()}`);
+      return Web3Number.fromWei(output.toString(), this.config.debt.decimals);
+    }
+    const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address]);
+    logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap debt_cap: ${output.debt_cap.toString()}`);
+    return Web3Number.fromWei(output.debt_cap.toString(), this.config.debt.decimals);
+  }
+
+  async getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number) {
+    const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
+    let interestRateConfigContract = contract;
+    if (!isV2) {
+      const extensionAddr = extensionMap[this.config.poolId.address];
+      if (!extensionAddr) {
+        throw new Error('Extension address not found');
+      }
+      interestRateConfigContract = new Contract({abi: VesuExtensionAbi, address: extensionAddr.address, providerOrAccount: config.provider});
+
+    }
+    const _interestRateConfig: any = await interestRateConfigContract.call(
+      'interest_rate_config', 
+      isV2 ? [this.config.debt.address.address] : [this.config.poolId.address, this.config.debt.address.address]
+    );
+    const interestRateConfig: InterestRateConfig = {
+      target_utilization: _interestRateConfig.target_utilization,
+      zero_utilization_rate: _interestRateConfig.zero_utilization_rate,
+      target_rate_percent: _interestRateConfig.target_rate_percent,
+      min_target_utilization: _interestRateConfig.min_target_utilization,
+      max_target_utilization: _interestRateConfig.max_target_utilization,
+      rate_half_life: _interestRateConfig.rate_half_life,
+      min_full_utilization_rate: _interestRateConfig.min_full_utilization_rate,
+      max_full_utilization_rate: _interestRateConfig.max_full_utilization_rate,
+    };
+    
+    const _assetConfig: any = await contract.call(
+      isV2 ? 'asset_config' : 'asset_config_unsafe', 
+      isV2 ? [asset.address.address] : [this.config.poolId.address, asset.address.address]
+    );
+    const assetConfig = isV2 ? _assetConfig : _assetConfig['0'];
+    const timeDelta = assetConfig.last_updated;
+    const lastFullUtilizationRate = assetConfig.last_full_utilization_rate;
+    const totalSupply = (new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals)).plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
+
+    const ratePerSecond = BigInt(Math.round(maxBorrowAPY / 365 / 24 / 60 / 60 * Number(SCALE)));
+    const maxUtilisation = this.getMaxUtilizationGivenRatePerSecond(interestRateConfig, ratePerSecond, timeDelta, lastFullUtilizationRate);
+    logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate maxUtilisation: ${Number(maxUtilisation) / 1e18}, totalSupply: ${totalSupply.toString()}`);
+   
+    const maxDebtToHave = totalSupply.multipliedBy(Number(maxUtilisation) / 1e18);
+    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    return maxDebtToHave.minus(currentDebt);
+  }
+
   async getLTVConfig(config: IConfig) {
     const CACHE_KEY = 'ltv_config';
     const cacheData = this.getCache<number>(CACHE_KEY);
@@ -516,6 +598,9 @@ export class VesuAdapter extends BaseAdapter {
       const output: any = await contract.call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
       ltv = Number(output.max_ltv) / 1e18;
     }
+    if (ltv == 0) {
+      throw new Error('LTV is 0');
+    }
     this.setCache(CACHE_KEY, ltv, 300000); // ttl: 5min
     return this.getCache<number>(CACHE_KEY) as number;
   }
@@ -673,4 +758,120 @@ export class VesuAdapter extends BaseAdapter {
       Global.setGlobalCache(CACHE_KEY, { pools, isErrorPoolsAPI }, 300000); // cache for 5 minutes
       return { pools, isErrorPoolsAPI };
   }
+
+
+  fullUtilizationRate(
+    interestRateConfig: InterestRateConfig,
+    timeDelta: bigint,
+    utilization: bigint,
+    fullUtilizationRate: bigint
+  ): bigint {
+    const {
+      min_target_utilization,
+      max_target_utilization,
+      rate_half_life,
+      min_full_utilization_rate,
+      max_full_utilization_rate,
+    } = interestRateConfig;
+  
+    const halfLifeScaled = rate_half_life * SCALE;
+  
+    let nextFullUtilizationRate: bigint;
+  
+    if (utilization < min_target_utilization) {
+      const utilizationDelta =
+        ((min_target_utilization - utilization) * SCALE) / min_target_utilization;
+      const decay = halfLifeScaled + utilizationDelta * timeDelta;
+      nextFullUtilizationRate = (fullUtilizationRate * halfLifeScaled) / decay;
+    } else if (utilization > max_target_utilization) {
+      const utilizationDelta =
+        ((utilization - max_target_utilization) * SCALE) /
+        (UTILIZATION_SCALE - max_target_utilization);
+      const growth = halfLifeScaled + utilizationDelta * timeDelta;
+      nextFullUtilizationRate = (fullUtilizationRate * growth) / halfLifeScaled;
+    } else {
+      nextFullUtilizationRate = fullUtilizationRate;
+    }
+  
+    if (nextFullUtilizationRate > max_full_utilization_rate) {
+      return max_full_utilization_rate;
+    } else if (nextFullUtilizationRate < min_full_utilization_rate) {
+      return min_full_utilization_rate;
+    } else {
+      return nextFullUtilizationRate;
+    }
+  }
+
+  /**
+   * Calculates new interest rate per second and next full utilization rate.
+   */
+  calculateInterestRate(
+    interestRateConfig: InterestRateConfig,
+    utilization: bigint,
+    timeDelta: bigint,
+    lastFullUtilizationRate: bigint
+  ): { newRatePerSecond: bigint; nextFullUtilizationRate: bigint } {
+    const scaledUtilization = utilization / UTILIZATION_SCALE_TO_SCALE;
+  
+    const {
+      target_utilization,
+      zero_utilization_rate,
+      target_rate_percent,
+    } = interestRateConfig;
+  
+    const nextFullUtilizationRate = this.fullUtilizationRate(
+      interestRateConfig,
+      timeDelta,
+      scaledUtilization,
+      lastFullUtilizationRate
+    );
+  
+    const targetRate =
+      (((nextFullUtilizationRate - zero_utilization_rate) * target_rate_percent) / SCALE) +
+      zero_utilization_rate;
+  
+    let newRatePerSecond: bigint;
+  
+    if (scaledUtilization < target_utilization) {
+      newRatePerSecond =
+        zero_utilization_rate +
+        (scaledUtilization * (targetRate - zero_utilization_rate)) /
+          target_utilization;
+    } else {
+      newRatePerSecond =
+        targetRate +
+        ((scaledUtilization - target_utilization) *
+          (nextFullUtilizationRate - targetRate)) /
+          (UTILIZATION_SCALE - target_utilization);
+    }
+  
+    return { newRatePerSecond, nextFullUtilizationRate };
+  }
+  
+  /**
+   * Calculates utilization given a specific rate per second.
+   * This is an inverse function of the piecewise interest rate formula above.
+   */
+  getMaxUtilizationGivenRatePerSecond(
+    interestRateConfig: InterestRateConfig,
+    ratePerSecond: bigint,
+    timeDelta: bigint,
+    last_full_utilization_rate: bigint
+  ): bigint {
+    logger.verbose(`VesuAdapter::getMaxUtilizationGivenRatePerSecond ratePerSecond: ${Number(ratePerSecond) / 1e18}, timeDelta: ${Number(timeDelta) / 1e18}, last_full_utilization_rate: ${Number(last_full_utilization_rate) / 1e18}`);
+    // use binary search to find the max utilization
+    // vary utlisation from 0 to SCALE, answer is the utilisation where the next step > ratePerSecond and the previous step < ratePerSecond
+    // Step is vary by SCALE / 100
+    let utilization = 0n;
+    let nextUtilization = SCALE / 100n;
+    while (utilization <= SCALE) {
+      logger.verbose(`VesuAdapter::getMaxUtilizationGivenRatePerSecond utilization: ${Number(utilization) / 1e18}, nextUtilization: ${Number(nextUtilization) / 1e18}`);
+      const { newRatePerSecond } = this.calculateInterestRate(interestRateConfig, utilization, timeDelta, last_full_utilization_rate);
+      if (newRatePerSecond > ratePerSecond) {
+        return utilization;
+      }
+      utilization += nextUtilization;
+    }
+    throw new Error('Max utilization not found');
+  }
 }

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

@@ -1,4 +1,4 @@
-import { FAQ, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType } from "@/interfaces";
+import { FAQ, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, TokenInfo } from "@/interfaces";
 import { AUMTypes, getContractDetails, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalManageCall, UniversalStrategy, UniversalStrategySettings } from "./universal-strategy";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
@@ -12,12 +12,15 @@ import { SingleTokenInfo } from "./base-strategy";
 import { Call, Contract, uint256 } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 
+export interface HyperLSTStrategySettings extends UniversalStrategySettings {
+  borrowable_assets: TokenInfo[];
+}
 
-export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalStrategySettings> {
+export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
   
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
   
-  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<UniversalStrategySettings>) {
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>) {
     super(config, pricer, metadata);
 
     const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
@@ -39,14 +42,32 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     return `${UniversalLstMultiplierStrategy.name}:${this.metadata.name}`;
   }
 
+  // Vesu adapter with LST and base token match
+  getVesuSameTokenAdapter() {
+    const baseAdapter = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    baseAdapter.networkConfig = this.config;
+    baseAdapter.pricer = this.pricer;
+    return baseAdapter;
+  }
+
   // only one leg is used
   // todo support lending assets of underlying as well (like if xSTRK looping is not viable, simply supply STRK)
   getVesuAdapters() {
-    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
-    vesuAdapter1.pricer = this.pricer;
-    vesuAdapter1.networkConfig = this.config;
-    
-    return [vesuAdapter1];
+    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);
+    }
+    return adapters;
   }
 
   // not applicable for this strategy
@@ -84,7 +105,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     // TODO use a varibale for 1.02
     return this._getAvnuDepositSwapLegCall({
       ...params,
-      minHF: 1.02
+      minHF: 1.1 // undo
     });
   }
 
@@ -123,6 +144,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     const totalDebtAmount = totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF);
     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}`);
     const debtAmount = totalDebtAmount.minus(existingDebtInfo.amount);
+    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
     if (debtAmount.lt(0)) {
       // this is to unwind the position to optimal HF. 
       const lstDEXPrice = await this.getLSTDexPrice();
@@ -131,10 +153,9 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
         isDeposit: false,
         leg1DepositAmount: debtAmountInLST
       })
-      assert(calls.length == 1, 'Expected 1 call for unwind');
+      assert(calls.length == 1, `Expected 1 call for unwind, got ${calls.length}`);
       return calls[0];
     }
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
     const STEP0 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
     const manage0Info = this.getProofs<ApproveCallParams>(STEP0);
     const manageCall0 = manage0Info.callConstructor({
@@ -261,11 +282,42 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     }
   }
 
+  protected async getVesuAUM(adapter: VesuAdapter) {
+    const legAUM = await adapter.getPositions(this.config);
+    const underlying = this.asset();
+    // assert its an LST of Endur
+    assert(underlying.symbol.startsWith('x'), 'Underlying is not an LST of Endur');
+
+    let vesuAum = Web3Number.fromWei("0", underlying.decimals);
+    
+    let tokenUnderlyingPrice = await this.getLSTExchangeRate();
+    // to offset for usual DEX lag, we multiply by 0.998 (i.e. 0.2% loss)
+    tokenUnderlyingPrice = tokenUnderlyingPrice * 0.998;
+    logger.verbose(`${this.getTag()} tokenUnderlyingPrice: ${tokenUnderlyingPrice}`);
+    
+    // handle collateral
+    if (legAUM[0].token.address.eq(underlying.address)) {
+      vesuAum = vesuAum.plus(legAUM[0].amount);
+    } else {
+      vesuAum = vesuAum.plus(legAUM[0].amount.dividedBy(tokenUnderlyingPrice));
+    }
+
+    // handle debt
+    if (legAUM[1].token.address.eq(underlying.address)) {
+      vesuAum = vesuAum.minus(legAUM[1].amount);
+    } else {
+      vesuAum = vesuAum.minus(legAUM[1].amount.dividedBy(tokenUnderlyingPrice));
+    };
+
+    logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);
+    return vesuAum;
+  }
+
   //
   private async _getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number) {
     const lstTruePrice = await this.getLSTExchangeRate();
     // during buy, the purchase should always be <= true LST price. 
-    const minOutputAmount = amountInUnderlying.dividedBy(lstTruePrice);
+    const minOutputAmount = amountInUnderlying.dividedBy(lstTruePrice).multipliedBy(0.99979); // minus 0.021% to account for avnu fees
     return minOutputAmount;
   }
 
@@ -292,6 +344,18 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     const legLTV = await vesuAdapter1.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
 
+    if (!params.isDeposit) {
+      // try using unused balance to unwind. 
+      // no need to unwind. 
+      const unusedBalance = await this.getUnusedBalance();
+      logger.verbose(`${this.getTag()}::getVesuMultiplyCall unusedBalance: ${unusedBalance.amount.toString()}, required: ${params.leg1DepositAmount.toString()}`);
+      // undo
+      // if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
+      //   return [];
+      // }
+      // throw new Error('Unused balance is less than the amount to unwind');
+    }
+
     const existingPositions = await vesuAdapter1.getPositions(this.config);
     const collateralisation = await vesuAdapter1.getCollateralization(this.config);
     const existingCollateralInfo = existingPositions[0];
@@ -350,17 +414,37 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   }
 
   getLSTUnderlyingTokenInfo() {
-    const [vesuAdapter1] = this.getVesuAdapters();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter();
     return vesuAdapter1.config.debt;
   }
 
+  async getMaxBorrowableAmount() {
+    const vesuAdapters = this.getVesuAdapters();
+    let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
+    const maxBorrowables: {amount: Web3Number, borrowableAsset: TokenInfo}[] = [];
+    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+    const maxInterestRate = lstAPY * 0.8;
+    for (const vesuAdapter of vesuAdapters) {
+      const maxBorrowableAmount = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
+      const debtCap = await vesuAdapter.getDebtCap(this.config);
+      maxBorrowables.push({amount: maxBorrowableAmount.minimum(debtCap), borrowableAsset: vesuAdapter.config.debt});
+    }
+    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));
+    return {netMaxBorrowableAmount, maxBorrowables};
+  }
+
+  // todo how much to unwind to get back healthy APY zone again
+  // if net APY < LST APR + 0.5%, we need to unwind to get back to LST APR + 1% atleast or 0 vesu position
+  // For xSTRK, simply deposit in Vesu if looping is not viable 
+  
   /**
    * Gets LST APR for the strategy's underlying asset from Endur API
    * @returns Promise<number> The LST APR (not divided by 1e18)
    */
   async getLSTAPR(_address: ContractAddr): Promise<number> {
     try {
-      const vesuAdapter1 = this.getVesuAdapters()[0];
+      const vesuAdapter1 = this.getVesuSameTokenAdapter();
       const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
       if (!apr) {
         throw new Error('Failed to get LST APR');
@@ -374,22 +458,50 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
 
   // todo undo this
   async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
-    const { net, splits } = await super.netAPY();
-    let _net = net;
-    if (this.asset().symbol == 'xWBTC') {
-      const debtToken = this.getVesuAdapters()[0].config.debt;
-      const lstAPY = await this.getLSTAPR(debtToken.address);
-      _net = lstAPY * 5;
+    const unusedBalance = await this.getUnusedBalance();
+    const maxNewDeposits = await this.maxNewDeposits();
+
+    // if unused balance is > max servicable from loan, we are limited by the max borrowing we can do
+    // we also allow accepting little higher deposits (1.5x) to have room for future looping when theres more liquidity or debt cap rises
+    if (maxNewDeposits * 1.5 < unusedBalance.amount.toNumber()) {
+      // we have excess, just use real APY
+      return super.netAPY();
+    } else {
+      // we have little bit room to accept more deposits, we use theoretical max APY
+      const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+      const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+      return this.returnNetAPY(baseAPYs, rewardAPYs, weights);
     }
-    return {
-      net: _net,
-      splits: splits
+  }
+
+  async maxNewDeposits() {
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount();
+    
+    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) {
+        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');
+    }
+    // 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.getVesuAdapters()[0];
+    const vesuAdapter = this.getVesuSameTokenAdapter();
     const underlying = vesuAdapter.config.debt;
     const lstAPY = await this.getLSTAPR(underlying.address);
     return {
@@ -398,7 +510,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   }
 
   async getLSTExchangeRate() {
-    const [vesuAdapter1] = this.getVesuAdapters();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter();
     const lstTokenInfo = vesuAdapter1.config.collateral;
     const lstABI = new Contract({
       abi: ERC4626Abi,
@@ -425,7 +537,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     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.getVesuAdapters();
+    const vesuAdapter1 = this.getVesuSameTokenAdapter();
     const lstTokenInfo = this.asset();
     const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
 
@@ -604,7 +716,7 @@ enum LST_MULTIPLIER_MANAGE_IDS  {
 function getLooperSettings(
   lstSymbol: string,
   underlyingSymbol: string,
-  vaultSettings: UniversalStrategySettings,
+  vaultSettings: HyperLSTStrategySettings,
   pool1: ContractAddr,
 ) {
   vaultSettings.leafAdapters = [];
@@ -730,7 +842,11 @@ const _riskFactor: RiskFactor[] = [
   {type: RiskType.DEPEG_RISK, value: DepegRiskLevel.GENERALLY_STABLE, weight: 25, reason: "Generally stable pegged assets" },
 ];
 
-const hyperxSTRK: UniversalStrategySettings = {
+const borrowableAssets = [
+  'WBTC', 'tBTC', 'LBTC', 'solvBTC'
+]
+
+const hyperxSTRK: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960'),
   manager: ContractAddr.from('0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a'),
   vaultAllocator: ContractAddr.from('0x511d07953a09bc7c505970891507c5a2486d2ea22752601a14db092186d7caa'),
@@ -739,10 +855,11 @@ const hyperxSTRK: UniversalStrategySettings = {
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
-  minHealthFactor: 1.05
+  minHealthFactor: 1.05,
+  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'STRK'),
 }
 
-const hyperxWBTC: UniversalStrategySettings = {
+const hyperxWBTC: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x2da9d0f96a46b453f55604313785dc866424240b1c6811d13bef594343db818'),
   manager: ContractAddr.from('0x75866db44c81e6986f06035206ee9c7d15833ddb22d6a22c016cfb5c866a491'),
   vaultAllocator: ContractAddr.from('0x57b5c1bb457b5e840a2714ae53ada87d77be2f3fd33a59b4fe709ef20c020c1'),
@@ -751,10 +868,11 @@ const hyperxWBTC: UniversalStrategySettings = {
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
-  minHealthFactor: 1.05
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
 }
 
-const hyperxtBTC: UniversalStrategySettings = {
+const hyperxtBTC: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x47d5f68477e5637ce0e56436c6b5eee5a354e6828995dae106b11a48679328'),
   manager: ContractAddr.from('0xc4cc3e08029a0ae076f5fdfca70575abb78d23c5cd1c49a957f7e697885401'),
   vaultAllocator: ContractAddr.from('0x50bbd4fe69f841ecb13b2619fe50ebfa4e8944671b5d0ebf7868fd80c61b31e'),
@@ -763,10 +881,11 @@ const hyperxtBTC: UniversalStrategySettings = {
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
-  minHealthFactor: 1.05
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
 }
 
-const hyperxsBTC: UniversalStrategySettings = {
+const hyperxsBTC: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x437ef1e7d0f100b2e070b7a65cafec0b2be31b0290776da8b4112f5473d8d9'),
   manager: ContractAddr.from('0xc9ac023090625b0be3f6532ca353f086746f9c09f939dbc1b2613f09e5f821'),
   vaultAllocator: ContractAddr.from('0x60c2d856936b975459a5b4eb28b8672d91f757bd76cebb6241f8d670185dc01'),
@@ -775,10 +894,11 @@ const hyperxsBTC: UniversalStrategySettings = {
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
-  minHealthFactor: 1.05
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
 }
 
-const hyperxLBTC: UniversalStrategySettings = {
+const hyperxLBTC: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x64cf24d4883fe569926419a0569ab34497c6956a1a308fa883257f7486d7030'),
   manager: ContractAddr.from('0x203530a4022a99b8f4b406aaf33b0849d43ad7422c1d5cc14ff8c667abec6c0'),
   vaultAllocator: ContractAddr.from('0x7dbc8ccd4eabce6ea6c19e0e5c9ccca3a93bd510303b9e071cbe25fc508546e'),
@@ -787,7 +907,8 @@ const hyperxLBTC: UniversalStrategySettings = {
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
-  minHealthFactor: 1.05
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
 }
 
 function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
@@ -800,7 +921,7 @@ function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
   ]
 }
 
-function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: UniversalStrategySettings, isPreview: boolean = false): IStrategyMetadata<UniversalStrategySettings> {
+function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: HyperLSTStrategySettings, isPreview: boolean = false): IStrategyMetadata<HyperLSTStrategySettings> {
   return {
     name: `Hyper ${lstSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
@@ -822,11 +943,12 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
     contractDetails: getContractDetails(addresses),
     faqs: getFAQs(lstSymbol, underlyingSymbol),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
-    isPreview: isPreview
+    isPreview: isPreview,
+    apyMethodology: 'Current annualized APY in terms of base asset of the LST'
   }
 }
 
-export const HyperLSTStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
+export const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[] =
   [
     getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false),
     getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false),