@strkfarm/sdk 1.1.28 → 1.1.31

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

@@ -3,10 +3,10 @@ import { AUMTypes, getContractDetails, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS,
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
-import { ApproveCallParams, CommonAdapter, getVesuSingletonAddress, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
-import { AVNU_MIDDLEWARE } from "./universal-adapters/adapter-utils";
+import { ApproveCallParams, AvnuSwapCallParams, CommonAdapter, getVesuSingletonAddress, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuModifyPositionCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
+import { AVNU_EXCHANGE } from "./universal-adapters/adapter-utils";
 import { DepegRiskLevel, LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
-import { EkuboQuoter, ERC20, LSTAPRService, PricerLST } from "@/modules";
+import { AvnuWrapper, EkuboQuoter, ERC20, LSTAPRService, PricerLST } from "@/modules";
 import { assert, logger } from "@/utils";
 import { SingleTokenInfo } from "./base-strategy";
 import { Call, Contract, uint256 } from "starknet";
@@ -76,6 +76,209 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
     return price;
   }
 
+
+  async getAvnuSwapMultiplyCall(params: {
+    isDeposit: boolean,
+    leg1DepositAmount: Web3Number
+  }) {
+    // TODO use a varibale for 1.02
+    return this._getAvnuDepositSwapLegCall({
+      ...params,
+      minHF: 1.02
+    });
+  }
+
+  private async _getAvnuDepositSwapLegCall(params: {
+    isDeposit: boolean,
+    leg1DepositAmount: Web3Number, 
+    minHF: number // e.g. 1.01
+  }) {
+    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
+    assert(params.isDeposit, 'Only deposit is supported in _getAvnuDepositSwapLegCall')
+    // add collateral
+    // borrow STRK (e.g.)
+    // approve and swap strk
+    // add collateral again
+
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`);
+    const existingPositions = await vesuAdapter1.getPositions(this.config);
+    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
+    const existingCollateralInfo = existingPositions[0];
+    const existingDebtInfo = existingPositions[1];
+    logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+    // - Prices as seen by Vesu contracts, ideal for HF math
+    // Price 1 is ok as fallback bcz that would relatively price the 
+    // collateral and debt as equal.
+    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+    logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+
+
+    const totalCollateral = existingCollateralInfo.amount.plus(params.leg1DepositAmount);
+    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`);
+    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);
+    if (debtAmount.lt(0)) {
+      // this is to unwind the position to optimal HF. 
+      const lstDEXPrice = await this.getLSTDexPrice();
+      const debtAmountInLST = debtAmount.abs().dividedBy(lstDEXPrice);
+      const calls = await this.getVesuMultiplyCall({
+        isDeposit: false,
+        leg1DepositAmount: debtAmountInLST
+      })
+      assert(calls.length == 1, 'Expected 1 call for unwind');
+      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({
+      amount: params.leg1DepositAmount
+    });
+    const STEP1 = UNIVERSAL_MANAGE_IDS.VESU_LEG1;
+    const manage1Info = this.getProofs<VesuModifyPositionCallParams>(STEP1);
+    const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+        collateralAmount: params.leg1DepositAmount,
+        isAddCollateral: params.isDeposit,
+        debtAmount: debtAmount,
+        isBorrow: params.isDeposit
+    }));
+    
+    const proofIds: string[] = [STEP0, STEP1];
+    const manageCalls: ManageCall[] = [manageCall0, manageCall1];
+
+    // approve and swap to LST using avnu
+    // todo add non-zero check
+    if (debtAmount.gt(0)) {
+      const STEP2 = LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT;
+      const manage2Info = this.getProofs<ApproveCallParams>(STEP2);
+      const manageCall2 = manage2Info.callConstructor({
+        amount: debtAmount
+      });
+
+      const debtTokenInfo = vesuAdapter1.config.debt;
+      const lstTokenInfo = this.asset();
+      const avnuModule = new AvnuWrapper();
+      const quote = await avnuModule.getQuotes(
+        debtTokenInfo.address.address,
+        lstTokenInfo.address.address,
+        debtAmount.toWei(),
+        this.metadata.additionalInfo.vaultAllocator.address
+      );
+      const minAmount = await this._getMinOutputAmountLSTBuy(debtAmount);
+      const minAmountWei = (minAmount).toWei();
+      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall minAmount: ${minAmount}`);
+      const swapInfo = await avnuModule.getSwapInfo(
+        quote, 
+        this.metadata.additionalInfo.vaultAllocator.address, 
+        0, 
+        this.address.address,
+        minAmountWei
+      );
+      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
+      const STEP3 = LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT;
+      const manage3Info = this.getProofs<AvnuSwapCallParams>(STEP3);
+      const manageCall3 = manage3Info.callConstructor({
+        props: swapInfo
+      });
+      proofIds.push(STEP2);
+      proofIds.push(STEP3);
+      manageCalls.push(manageCall2, manageCall3);
+
+
+      // if the created debt, when added is collateral will put the total HF above min, but below (target + 0.05),
+      // then lets close the looping cycle by adding this as collateral. 
+      const newCollateral = minAmount.plus(totalCollateral);
+      const newHF = newCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(totalDebtAmount).dividedBy(debtPrice).toNumber();
+      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF: ${newHF}`);
+      if (newHF > this.metadata.additionalInfo.minHealthFactor && newHF < this.metadata.additionalInfo.targetHealthFactor + 0.05) {
+        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF is above min and below target + 0.05, adding collateral on vesu`);
+        // approve and add collateral on vesu (modify position)
+        const STEP4 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
+        const manage4Info = this.getProofs<ApproveCallParams>(STEP4);
+        const manageCall4 = manage4Info.callConstructor({
+          amount: minAmount
+        });
+       
+        const STEP5 = UNIVERSAL_MANAGE_IDS.VESU_LEG1;
+        const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP5);
+        const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+          collateralAmount: minAmount,
+          isAddCollateral: true,
+          debtAmount: Web3Number.fromWei('0', this.asset().decimals),
+          isBorrow: params.isDeposit
+        }));
+        proofIds.push(STEP4, STEP5);
+        manageCalls.push(manageCall4, manageCall5);
+      }
+    }
+
+    const manageCall = this.getManageCall(proofIds, manageCalls);
+    return manageCall;
+  }
+
+  // todo unwind or not deposit when the yield is bad. 
+
+  async getLSTMultiplierRebalanceCall(): Promise<{ shouldRebalance: boolean, manageCall: Call | undefined }> {
+    const positions = await this.getVaultPositions();
+    assert(positions.length == 3, 'Rebalance call is only supported for 3 positions');
+    const existingCollateralInfo = positions[0];
+    const existingDebtInfo = positions[1];
+    const unusedBalance = positions[2];
+    const [healthFactor] = await this.getVesuHealthFactors();
+
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+    // - Prices as seen by Vesu contracts, ideal for HF math
+    // Price 1 is ok as fallback bcz that would relatively price the 
+    // collateral and debt as equal.
+    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+
+    const isHFTooLow = healthFactor < this.metadata.additionalInfo.minHealthFactor;
+    const isHFTooHigh = healthFactor > this.metadata.additionalInfo.targetHealthFactor + 0.05;
+    if (isHFTooLow || isHFTooHigh) {
+      // use unused collateral to target more. 
+      const manageCall = await this._getAvnuDepositSwapLegCall({
+        isDeposit: true,
+        leg1DepositAmount: unusedBalance.amount,
+        minHF: 1.02 // todo, shouldnt use this 1.02 HF, if there isn;t more looping left. 
+      })
+      return { shouldRebalance: true, manageCall };
+    } else {
+      // do nothing
+      return { shouldRebalance: false, manageCall: undefined };
+    }
+  }
+
+  //
+  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);
+    return minOutputAmount;
+  }
+
+  private async _getMinOutputAmountLSTSell(amountInLST: Web3Number) {
+    const lstTruePrice = await this.getLSTExchangeRate();
+    // during sell, the purchase should always be > 0.995 * true LST price. 
+    const minOutputAmount = amountInLST.multipliedBy(lstTruePrice).multipliedBy(0.995);
+    return minOutputAmount;
+  }
+
+  // todo add a function to findout max borrowable amount without fucking yield
+  // if the current net yield < LST yield, add a function to calculate how much to unwind. 
+
   /**
    * Uses vesu's multiple call to create leverage on LST
    * Deposit amount is in LST
@@ -158,13 +361,42 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
   async getLSTAPR(_address: ContractAddr): Promise<number> {
     try {
       const vesuAdapter1 = this.getVesuAdapters()[0];
-      return await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
+      const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
+      if (!apr) {
+        throw new Error('Failed to get LST APR');
+      }
+      return apr;
     } catch (error) {
       logger.warn(`${this.getTag()}: Failed to get LST APR: ${error}`);
       return 0;
     }
   }
 
+  // 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;
+    }
+    return {
+      net: _net,
+      splits: splits
+    }
+  }
+
+  protected async getUnusedBalanceAPY() {
+    const unusedBalance = await this.getUnusedBalance();
+    const vesuAdapter = this.getVesuAdapters()[0];
+    const underlying = vesuAdapter.config.debt;
+    const lstAPY = await this.getLSTAPR(underlying.address);
+    return {
+      apy: lstAPY, weight: unusedBalance.usdValue
+    }
+  }
+
   async getLSTExchangeRate() {
     const [vesuAdapter1] = this.getVesuAdapters();
     const lstTokenInfo = vesuAdapter1.config.collateral;
@@ -209,7 +441,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<UniversalS
 
     // approve token
     if (params.marginAmount.greaterThan(0)) {
-      const STEP1_ID = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
+      const STEP1_ID = LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE;
       const manage1Info = this.getProofs<ApproveCallParams>(STEP1_ID);
       const depositAmount = params.marginAmount;
       const manageCall1 = manage1Info.callConstructor({
@@ -349,9 +581,14 @@ function getDescription(tokenSymbol: string, underlyingSymbol: string) {
 }
 
 enum LST_MULTIPLIER_MANAGE_IDS  {
+  MULTIPLE_APPROVE = 'multiple_approve',
   MULTIPLY_VESU = 'multiply_vesu',
   SWITCH_DELEGATION_ON = 'switch_delegation_on',
-  SWITCH_DELEGATION_OFF = 'switch_delegation_off'
+  SWITCH_DELEGATION_OFF = 'switch_delegation_off',
+  AVNU_MULTIPLY_APPROVE_DEPOSIT = 'avnu_multiply_approve_deposit',
+  AVNU_MULTIPLY_SWAP_DEPOSIT = 'avnu_multiply_swap_deposit',
+  AVNU_MULTIPLY_APPROVE_WITHDRAW = 'avnu_multiply_approve_withdraw',
+  AVNU_MULTIPLY_SWAP_WITHDRAW = 'avnu_multiply_swap_withdraw',
 }
 
 function getLooperSettings(
@@ -370,7 +607,7 @@ function getLooperSettings(
     collateral: lstToken,
     debt: underlyingToken,
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU
+    id: UNIVERSAL_MANAGE_IDS.VESU_LEG1
   })
 
   const commonAdapter = new CommonAdapter({
@@ -382,10 +619,10 @@ function getLooperSettings(
   })
 
   // vesu looping
-  const { isV2 } = getVesuSingletonAddress(pool1);
+  const { isV2, addr:poolAddr } = getVesuSingletonAddress(pool1);
   const VESU_MULTIPLY = isV2 ? vesuAdapterLST.VESU_MULTIPLY : vesuAdapterLST.VESU_MULTIPLY_V1;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter.bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU).bind(vesuAdapterLST));
   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));
 
@@ -399,6 +636,15 @@ function getLooperSettings(
     adapter: commonAdapter
   }])
 
+  // avnu multiply
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(underlyingToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(underlyingToken.address, lstToken.address, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, false).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_WITHDRAW).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, underlyingToken.address, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_WITHDRAW, false).bind(commonAdapter));
+  // approve LST to add collateral
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getModifyPosition.bind(vesuAdapterLST));
+
   // to bridge liquidity back to vault (used by bring_liquidity)
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vaultSettings.vaultAddress, UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY).bind(commonAdapter));
@@ -408,8 +654,8 @@ function getLooperSettings(
 
   // avnu swap for claims rewards
   const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_EXCHANGE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS, false).bind(commonAdapter));
   return vaultSettings;
 }
 
@@ -523,11 +769,11 @@ const hyperxsBTC: UniversalStrategySettings = {
 }
 
 const hyperxLBTC: UniversalStrategySettings = {
-  vaultAddress: ContractAddr.from('0x38e96a301428d204ab4553799aa386a0f14a5ef9b30a5830be1814e4fb8da1c'),
-  manager: ContractAddr.from('0x18d376446d9df1f783e17aff1f21bac3d97aa3ba378e367742cdd744468ad35'),
-  vaultAllocator: ContractAddr.from('0x3e98774ca0508505ba6d7f17d95ec391648f44f947b0d211241464a4f5b9b20'),
-  redeemRequestNFT: ContractAddr.from('0x268017b4c8b2117ca0136d9a77e3666db44b143447566f0746ca0b1c9ab1e72'),
-  aumOracle: ContractAddr.from('0x521a3f339c65e918e0d8a065b14baef1ea25676bb7fca1e0238ac47e20d7755'),
+  vaultAddress: ContractAddr.from('0x64cf24d4883fe569926419a0569ab34497c6956a1a308fa883257f7486d7030'),
+  manager: ContractAddr.from('0x203530a4022a99b8f4b406aaf33b0849d43ad7422c1d5cc14ff8c667abec6c0'),
+  vaultAllocator: ContractAddr.from('0x7dbc8ccd4eabce6ea6c19e0e5c9ccca3a93bd510303b9e071cbe25fc508546e'),
+  redeemRequestNFT: ContractAddr.from('0x5ee66a39af9aef3d0d48982b4a63e8bd2a5bad021916bd87fb0eae3a26800b8'),
+  aumOracle: ContractAddr.from('0x23d69e4391fa72d10e625e7575d8bddbb4aff96f04503f83fdde23123bf41d0'),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,

package/src/strategies/universal-strategy.tsx

@@ -9,7 +9,7 @@ import UniversalVaultAbi from '../data/universal-vault.abi.json';
 import ManagerAbi from '../data/vault-manager.abi.json';
 import { ApproveCallParams, AvnuSwapCallParams, BaseAdapter, CommonAdapter, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuAdapter, VesuDefiSpringRewardsCallParams, VesuModifyPositionCallParams, VesuPools } from "./universal-adapters";
 import { Global } from "@/global";
-import { AvnuWrapper, ERC20, LSTAPRService } from "@/modules";
+import { AvnuWrapper, ERC20 } from "@/modules";
 import { AVNU_MIDDLEWARE, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
 import { VesuHarvests } from "@/modules/harvests";
 
@@ -257,8 +257,13 @@ export class UniversalStrategy<
       }]};
     }
 
+    const unusedBalanceAPY = await this.getUnusedBalanceAPY();
+    baseAPYs.push(...[unusedBalanceAPY.apy]);
+    rewardAPYs.push(0);
+
     // Compute APy using weights
     const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+    weights.push(unusedBalanceAPY.weight);
     const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
     const prevAUMUSD = prevAUM.multipliedBy(price.price);
     const baseAPY = this.computeAPY(baseAPYs, weights, prevAUMUSD);
@@ -272,6 +277,12 @@ export class UniversalStrategy<
     }] };
   }
 
+  protected async getUnusedBalanceAPY() {
+    return {
+      apy: 0, weight: 0
+    }
+  }
+
   private computeAPY(apys: number[], weights: number[], currentAUM: Web3Number) {
     assert(apys.length === weights.length, "APYs and weights length mismatch");
     const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
@@ -875,7 +886,7 @@ function getLooperSettings(
   // avnu swap
   const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS, true).bind(commonAdapter));
   return vaultSettings;
 }