@strkfarm/sdk 1.0.56 → 1.0.57

package/dist/index.browser.mjs

@@ -1937,7 +1937,6 @@ import { toHex } from "@ericnordelo/strk-merkle-tree/dist/bytes";
 import { processMultiProof, processProof } from "@ericnordelo/strk-merkle-tree/dist/core";
 import { standardLeafHash } from "@ericnordelo/strk-merkle-tree/dist/hashes";
 import { MerkleTreeImpl } from "@ericnordelo/strk-merkle-tree/dist/merkletree";
-import { validateArgument } from "@ericnordelo/strk-merkle-tree/src/utils/errors";
 import { num as num2 } from "starknet";
 
 // ../node_modules/@noble/hashes/esm/_assert.js
@@ -3994,13 +3993,6 @@ var StandardMerkleTree = class _StandardMerkleTree extends MerkleTreeImpl {
     });
     return new _StandardMerkleTree(tree, indexedValues, leafEncoding);
   }
-  static load(data) {
-    validateArgument(data.format === "standard-v1", `Unknown format '${data.format}'`);
-    validateArgument(data.leafEncoding !== void 0, "Expected leaf encoding");
-    const tree = new _StandardMerkleTree(data.tree, data.values, data.leafEncoding);
-    tree.validate();
-    return tree;
-  }
   static verify(root, leafEncoding, leaf, proof) {
     return toHex(root) === processProof(standardLeafHash(leafEncoding, leaf), proof);
   }
@@ -5758,23 +5750,10 @@ var vesu_rebalance_abi_default = [
   }
 ];
 
-// src/strategies/base-strategy.ts
-var BaseStrategy = class {
-  constructor(config) {
+// src/utils/cacheClass.ts
+var CacheClass = class {
+  constructor() {
     this.cache = /* @__PURE__ */ new Map();
-    this.config = config;
-  }
-  async getUserTVL(user) {
-    throw new Error("Not implemented");
-  }
-  async getTVL() {
-    throw new Error("Not implemented");
-  }
-  async depositCall(amountInfo, receiver) {
-    throw new Error("Not implemented");
-  }
-  async withdrawCall(amountInfo, receiver, owner) {
-    throw new Error("Not implemented");
   }
   setCache(key, data, ttl = 6e4) {
     const timestamp = Date.now();
@@ -5795,6 +5774,27 @@ var BaseStrategy = class {
   }
 };
 
+// src/strategies/base-strategy.ts
+var BaseStrategy = class extends CacheClass {
+  constructor(config) {
+    super();
+    this.cache = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  async getUserTVL(user) {
+    throw new Error("Not implemented");
+  }
+  async getTVL() {
+    throw new Error("Not implemented");
+  }
+  async depositCall(amountInfo, receiver) {
+    throw new Error("Not implemented");
+  }
+  async withdrawCall(amountInfo, receiver, owner) {
+    throw new Error("Not implemented");
+  }
+};
+
 // src/node/headless.browser.ts
 import axios5 from "axios";
 async function getAPIUsingHeadlessBrowser(url) {
@@ -20268,9 +20268,8 @@ var SenseiVault = class extends BaseStrategy {
   }
   async getPositionInfo() {
     const CACHE_KEY = "positionInfo";
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
     const resp = await fetch(
       `${getTrovesEndpoint()}/vesu/positions?walletAddress=${this.address.address}`
     );
@@ -20314,9 +20313,8 @@ var SenseiVault = class extends BaseStrategy {
   }
   async getSecondaryTokenPriceRelativeToMain(retry = 0) {
     const CACHE_KEY = "xSTRKPrice";
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
     const params = {
       sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
       buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,
@@ -20470,7 +20468,7 @@ function toBigInt(value) {
 }
 
 // src/strategies/universal-adapters/baseAdapter.ts
-var BaseAdapter = class {
+var BaseAdapter = class extends CacheClass {
   constructSimpleLeafData(params) {
     const { id, target, method, packedArguments } = params;
     return {
@@ -22845,7 +22843,6 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
   constructor(config) {
     super();
     this.VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
-    this.cache = {};
     this.getModifyPosition = () => {
       const positionData = [0n];
       const packedArguments = [
@@ -22874,17 +22871,19 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
         value: {
           abs: uint2567.bnToUint256(params.collateralAmount.value.abs.toWei()),
-          is_negative: params.collateralAmount.value.is_negative
+          is_negative: params.collateralAmount.value.abs.isZero() ? false : params.collateralAmount.value.is_negative
         }
       };
+      logger.verbose(`VesuAdapter::ConstructingModify::Collateral::${JSON.stringify(_collateral)}`);
       const _debt = {
         amount_type: this.formatAmountTypeEnum(params.debtAmount.amount_type),
         denomination: this.formatAmountDenominationEnum(params.debtAmount.denomination),
         value: {
           abs: uint2567.bnToUint256(params.debtAmount.value.abs.toWei()),
-          is_negative: params.debtAmount.value.is_negative
+          is_negative: params.debtAmount.value.abs.isZero() ? false : params.debtAmount.value.is_negative
         }
       };
+      logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`);
       const singletonContract = new Contract8(vesu_singleton_abi_default, this.VESU_SINGLETON.toString(), new RpcProvider4({ nodeUrl: "" }));
       const call = singletonContract.populate("modify_position", {
         params: {
@@ -22953,20 +22952,22 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
   }
   async getLTVConfig(config) {
     const CACHE_KEY = "ltv_config";
-    if (this.cache[CACHE_KEY]) {
-      return this.cache[CACHE_KEY];
+    const cacheData = this.getCache(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
     }
     const output2 = await this.getVesuSingletonContract(config).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
-    this.cache[CACHE_KEY] = Number(output2.max_ltv) / 1e18;
-    return this.cache[CACHE_KEY];
+    this.setCache(CACHE_KEY, Number(output2.max_ltv) / 1e18, 3e5);
+    return this.getCache(CACHE_KEY);
   }
   async getPositions(config) {
     if (!this.pricer) {
       throw new Error("Pricer is not initialized");
     }
     const CACHE_KEY = "positions";
-    if (this.cache[CACHE_KEY]) {
-      return this.cache[CACHE_KEY];
+    const cacheData = this.getCache(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
     }
     const output2 = await this.getVesuSingletonContract(config).call("position_unsafe", [
       this.config.poolId.address,
@@ -22989,9 +22990,65 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
       remarks: "Debt"
     }];
-    this.cache[CACHE_KEY] = value;
+    this.setCache(CACHE_KEY, value, 6e4);
+    return value;
+  }
+  async getCollateralization(config) {
+    if (!this.pricer) {
+      throw new Error("Pricer is not initialized");
+    }
+    const CACHE_KEY = "collateralization";
+    const cacheData = this.getCache(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
+    }
+    const output2 = await this.getVesuSingletonContract(config).call("check_collateralization_unsafe", [
+      this.config.poolId.address,
+      this.config.collateral.address.address,
+      this.config.debt.address.address,
+      this.config.vaultAllocator.address
+    ]);
+    const collateralAmount = Web3Number.fromWei(output2["1"].toString(), 18);
+    const debtAmount = Web3Number.fromWei(output2["2"].toString(), 18);
+    const value = [{
+      token: this.config.collateral,
+      usdValue: collateralAmount.toNumber(),
+      remarks: "Collateral"
+    }, {
+      token: this.config.debt,
+      usdValue: debtAmount.toNumber(),
+      remarks: "Debt"
+    }];
+    this.setCache(CACHE_KEY, value, 6e4);
     return value;
   }
+  async getAssetPrices() {
+    const collateralizationProm = this.getCollateralization(this.networkConfig);
+    const positionsProm = this.getPositions(this.networkConfig);
+    const ltvProm = this.getLTVConfig(this.networkConfig);
+    const output2 = await Promise.all([collateralizationProm, positionsProm, ltvProm]);
+    const [collateralization, positions, ltv] = output2;
+    const collateralTokenAmount = positions[0].amount;
+    const collateralUSDAmount = collateralization[0].usdValue;
+    const collateralPrice = collateralUSDAmount / collateralTokenAmount.toNumber();
+    const debtTokenAmount = positions[1].amount;
+    const debtUSDAmount = collateralization[1].usdValue;
+    const debtPrice = debtUSDAmount / debtTokenAmount.toNumber();
+    return {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    };
+  }
+  async getHealthFactor() {
+    const ltv = await this.getLTVConfig(this.networkConfig);
+    const collateralisation = await this.getCollateralization(this.networkConfig);
+    return collateralisation[0].usdValue * ltv / collateralisation[1].usdValue;
+  }
   static async getVesuPools(retry = 0) {
     const CACHE_KEY = "VESU_POOLS";
     const cacheValue = Global.getGlobalCache(CACHE_KEY);
@@ -25363,19 +25420,32 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const debtAsset1 = pool1.assets.find((a) => a.symbol === vesuAdapter1.config.debt.symbol)?.stats;
     const collateralAsset2 = pool2.assets.find((a) => a.symbol === vesuAdapter2.config.collateral.symbol)?.stats;
     const debtAsset2 = pool2.assets.find((a) => a.symbol === vesuAdapter2.config.debt.symbol)?.stats;
-    const collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18 + Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18;
+    const collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18;
     const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
-    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18 + Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18;
+    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18;
     const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
-    const apys = [collateral1APY, debt1APY, collateral2APY, debt2APY];
     const positions = await this.getVaultPositions();
-    assert(positions.length == apys.length, "Positions and APYs length mismatch");
-    const weightedAPYs = positions.map((pos, i) => {
-      return pos.usdValue * apys[i] * (i % 2 == 0 ? 1 : -1);
-    });
-    const netPosition = positions.reduce((acc, val, index) => acc + val.usdValue * (index % 2 == 0 ? 1 : -1), 0);
-    const apy = weightedAPYs.reduce((acc, val) => acc + val, 0) / netPosition;
-    return apy;
+    const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+    const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
+    assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
+    const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
+    const baseAPY = this.computeAPY(baseAPYs, weights);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights);
+    const apys = [...baseAPYs, ...rewardAPYs];
+    const netAPY = baseAPY + rewardAPY;
+    return { net: netAPY, splits: [{
+      apy: baseAPY,
+      id: "base"
+    }, {
+      apy: rewardAPY,
+      id: "defispring"
+    }] };
+  }
+  computeAPY(apys, weights) {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    const totalWeight = weights.reduce((acc, weight) => acc + weight, 0);
+    return weightedSum / totalWeight;
   }
   /**
      * Calculates the total TVL of the strategy.
@@ -25398,22 +25468,48 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     };
   }
   async getAUM() {
+    const currentAUM = await this.contract.call("aum", []);
+    const lastReportTime = await this.contract.call("last_report_timestamp", []);
+    const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
     const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const leg1AUM = await vesuAdapter1.getPositions(this.config);
     const leg2AUM = await vesuAdapter2.getPositions(this.config);
-    const token1Price = await this.pricer.getPrice(vesuAdapter1.config.collateral.symbol);
     const aumToken = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount);
-    return {
+    logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
+    const netAPY = await this.netAPY();
+    const defispringAPY = netAPY.splits.find((s) => s.id === "defispring")?.apy || 0;
+    if (!defispringAPY) throw new Error("DefiSpring APY not found");
+    const timeDiff = Math.round(Date.now() / 1e3) - Number(lastReportTime);
+    const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    const rewardAssets = prevAum.multipliedBy(growthRate);
+    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
+    logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
+    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
+    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+    const newAUM = aumToken.plus(rewardAssets);
+    logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
+    const net = {
       tokenInfo: this.asset(),
-      amount: aumToken,
-      usdValue: aumToken.multipliedBy(token1Price.price).toNumber()
+      amount: newAUM,
+      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
     };
+    const splits = [{
+      id: "finalised",
+      aum: aumToken
+    }, {
+      id: "defispring",
+      aum: rewardAssets
+    }];
+    return { net, splits, prevAum };
   }
   getVesuAdapters() {
     const vesuAdapter1 = this.getAdapter("vesu_leg1_adapter" /* VESU_LEG1 */);
     const vesuAdapter2 = this.getAdapter("vesu_leg2_adapter" /* VESU_LEG2 */);
     vesuAdapter1.pricer = this.pricer;
     vesuAdapter2.pricer = this.pricer;
+    vesuAdapter1.networkConfig = this.config;
+    vesuAdapter2.networkConfig = this.config;
     return [vesuAdapter1, vesuAdapter2];
   }
   async getVaultPositions() {
@@ -25455,12 +25551,14 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     }));
     const output2 = [{
       proofs: manage5Info.proofs,
-      manageCall: manageCall5
+      manageCall: manageCall5,
+      step: STEP2_ID
     }];
     if (approveAmount.gt(0)) {
       output2.unshift({
         proofs: manage4Info.proofs,
-        manageCall: manageCall4
+        manageCall: manageCall4,
+        step: STEP1_ID
       });
     }
     return output2;
@@ -25468,9 +25566,96 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   getTag() {
     return `${_UniversalStrategy.name}:${this.metadata.name}`;
   }
+  async getVesuHealthFactors() {
+    return await Promise.all(this.getVesuAdapters().map((v) => v.getHealthFactor()));
+  }
+  async computeRebalanceConditionAndReturnCalls() {
+    const vesuAdapters = this.getVesuAdapters();
+    const healthFactors = await this.getVesuHealthFactors();
+    const leg1HealthFactor = healthFactors[0];
+    const leg2HealthFactor = healthFactors[1];
+    logger.verbose(`${this.getTag()}: HealthFactorLeg1: ${leg1HealthFactor}`);
+    logger.verbose(`${this.getTag()}: HealthFactorLeg2: ${leg2HealthFactor}`);
+    const minHf = this.metadata.additionalInfo.minHealthFactor;
+    const isRebalanceNeeded1 = leg1HealthFactor < minHf;
+    const isRebalanceNeeded2 = leg2HealthFactor < minHf;
+    if (!isRebalanceNeeded1 && !isRebalanceNeeded2) {
+      return [];
+    }
+    if (isRebalanceNeeded1) {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[0], leg1HealthFactor, false);
+      const leg2HF = await this.getNewHealthFactor(vesuAdapters[1], amount, true);
+      assert(leg2HF > minHf, `Rebalance Leg1 failed: Leg2 HF after rebalance would be too low: ${leg2HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: false,
+        amount
+      })];
+    } else {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[1], leg2HealthFactor, true);
+      const leg1HF = await this.getNewHealthFactor(vesuAdapters[0], amount, false);
+      assert(leg1HF > minHf, `Rebalance Leg2 failed: Leg1 HF after rebalance would be too low: ${leg1HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: true,
+        amount
+      })];
+    }
+  }
+  async getNewHealthFactor(vesuAdapter, newAmount, isWithdraw) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+    if (isWithdraw) {
+      const newHF = (collateralTokenAmount.toNumber() - newAmount.toNumber()) * collateralPrice * ltv / debtUSDAmount;
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isDeposit`);
+      return newHF;
+    } else {
+      const newHF = collateralUSDAmount * ltv / ((debtTokenAmount.toNumber() + newAmount.toNumber()) * debtPrice);
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isRepay`);
+      return newHF;
+    }
+  }
+  /**
+   * 
+   * @param vesuAdapter 
+   * @param currentHf 
+   * @param isDeposit if true, attempt by adding collateral, else by repaying
+   * @returns 
+   */
+  async getLegRebalanceAmount(vesuAdapter, currentHf, isDeposit) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+    if (debtTokenAmount.isZero()) {
+      return Web3Number.fromWei(0, 0);
+    }
+    assert(collateralPrice > 0 && debtPrice > 0, "getRebalanceAmount: Invalid price");
+    const targetHF = this.metadata.additionalInfo.targetHealthFactor;
+    if (currentHf > targetHF - 0.01)
+      throw new Error("getLegRebalanceAmount: Current health factor is healthy");
+    if (isDeposit) {
+      const newAmount = targetHF * debtUSDAmount / (collateralPrice * ltv) - collateralTokenAmount.toNumber();
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: addCollateral, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), collateralTokenAmount.decimals);
+    } else {
+      const newAmount = debtTokenAmount.toNumber() - collateralUSDAmount * ltv / (targetHF * debtPrice);
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: repayDebt, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), debtTokenAmount.decimals);
+    }
+  }
   async getVesuMultiplyCall(params) {
-    const vesuAdapter1 = this.getAdapter("vesu_leg1_adapter" /* VESU_LEG1 */);
-    const vesuAdapter2 = this.getAdapter("vesu_leg2_adapter" /* VESU_LEG2 */);
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const leg1LTV = await vesuAdapter1.getLTVConfig(this.config);
     const leg2LTV = await vesuAdapter2.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}: LTVLeg1: ${leg1LTV}`);
@@ -25479,7 +25664,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const token2Price = await this.pricer.getPrice(vesuAdapter2.config.collateral.symbol);
     logger.verbose(`${this.getTag()}: Price${vesuAdapter1.config.collateral.symbol}: ${token1Price.price}`);
     logger.verbose(`${this.getTag()}: Price${vesuAdapter2.config.collateral.symbol}: ${token2Price.price}`);
-    const TARGET_HF = 1.3;
+    const TARGET_HF = this.metadata.additionalInfo.targetHealthFactor;
     const k1 = token1Price.price * leg1LTV / token2Price.price / TARGET_HF;
     const k2 = token1Price.price * TARGET_HF / token2Price.price / leg2LTV;
     const borrow2Amount = new Web3Number(
@@ -25537,14 +25722,14 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     });
     if (params.isLeg1toLeg2) {
       const manageCall = this.getManageCall([
-        "vesu_leg1" /* VESU_LEG1 */,
-        "vesu_leg2" /* VESU_LEG2 */
+        ...callSet1.map((i) => i.step),
+        ...callSet2.map((i) => i.step)
       ], [...callSet1.map((i) => i.manageCall), ...callSet2.map((i) => i.manageCall)]);
       return manageCall;
     } else {
       const manageCall = this.getManageCall([
-        "vesu_leg2" /* VESU_LEG2 */,
-        "vesu_leg1" /* VESU_LEG1 */
+        ...callSet2.map((i) => i.step),
+        ...callSet1.map((i) => i.step)
       ], [...callSet2.map((i) => i.manageCall), ...callSet1.map((i) => i.manageCall)]);
       return manageCall;
     }
@@ -25612,14 +25797,18 @@ var usdcVaultSettings = {
   vaultAllocator: ContractAddr.from("0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba"),
   redeemRequestNFT: ContractAddr.from("0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda"),
   leafAdapters: [],
-  adapters: []
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
 };
 var wbtcVaultSettings = {
   manager: ContractAddr.from("0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34"),
   vaultAllocator: ContractAddr.from("0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735"),
   redeemRequestNFT: ContractAddr.from("0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2"),
   leafAdapters: [],
-  adapters: []
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
 };
 var UniversalStrategies = [
   {

package/dist/index.d.ts

@@ -380,6 +380,18 @@ declare class AutoCompounderSTRK {
     }>;
 }
 
+interface CacheData$1 {
+    timestamp: number;
+    ttl: number;
+    data: any;
+}
+declare class CacheClass {
+    readonly cache: Map<string, CacheData$1>;
+    setCache(key: string, data: any, ttl?: number): void;
+    getCache<T>(key: string): T | null;
+    isCacheValid(key: string): boolean;
+}
+
 interface SingleActionAmount {
     tokenInfo: TokenInfo;
     amount: Web3Number;
@@ -401,7 +413,7 @@ interface CacheData {
     ttl: number;
     data: any;
 }
-declare class BaseStrategy<TVLInfo, ActionInfo> {
+declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     readonly config: IConfig;
     readonly cache: Map<string, CacheData>;
     constructor(config: IConfig);
@@ -409,9 +421,6 @@ declare class BaseStrategy<TVLInfo, ActionInfo> {
     getTVL(): Promise<TVLInfo>;
     depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
     withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    setCache(key: string, data: any, ttl?: number): void;
-    getCache(key: string): any | null;
-    isCacheValid(key: string): boolean;
 }
 
 interface PoolProps {
@@ -866,7 +875,6 @@ declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
     protected readonly leafEncoding: ValueType[];
     protected constructor(tree: HexString[], values: StandardMerkleTreeData<LeafData>['values'], leafEncoding: ValueType[]);
     static of(values: LeafData[], leafEncoding?: ValueType[], options?: MerkleTreeOptions): StandardMerkleTree;
-    static load(data: StandardMerkleTreeData<LeafData>): StandardMerkleTree;
     static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean;
     static verifyMultiProof<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], multiproof: MultiProof<BytesLike, T>): boolean;
     dump(): StandardMerkleTreeData<LeafData>;
@@ -895,7 +903,7 @@ type AdapterLeafType<T> = {
     callConstructor: GenerateCallFn<T>;
 };
 type LeafAdapterFn<T> = () => AdapterLeafType<T>;
-declare class BaseAdapter {
+declare class BaseAdapter extends CacheClass {
     protected constructSimpleLeafData(params: {
         id: string;
         target: ContractAddr;
@@ -972,7 +980,6 @@ declare class VesuAdapter extends BaseAdapter {
     config: VesuAdapterConfig;
     networkConfig: IConfig | undefined;
     pricer: PricerBase | undefined;
-    cache: Record<string, any>;
     constructor(config: VesuAdapterConfig);
     getModifyPosition: () => AdapterLeafType<VesuModifyPositionCallParams>;
     static getDefaultModifyPositionCallParams(params: {
@@ -1004,6 +1011,17 @@ declare class VesuAdapter extends BaseAdapter {
     getVesuSingletonContract(config: IConfig): Contract;
     getLTVConfig(config: IConfig): Promise<number>;
     getPositions(config: IConfig): Promise<VaultPosition[]>;
+    getCollateralization(config: IConfig): Promise<Omit<VaultPosition, 'amount'>[]>;
+    getAssetPrices(): Promise<{
+        collateralTokenAmount: Web3Number;
+        collateralUSDAmount: number;
+        collateralPrice: number;
+        debtTokenAmount: Web3Number;
+        debtUSDAmount: number;
+        debtPrice: number;
+        ltv: number;
+    }>;
+    getHealthFactor(): Promise<number>;
     static getVesuPools(retry?: number): Promise<VesuPoolsInfo>;
 }
 
@@ -1016,6 +1034,8 @@ interface UniversalStrategySettings {
         id: string;
         adapter: BaseAdapter;
     }[];
+    targetHealthFactor: number;
+    minHealthFactor: number;
 }
 declare class UniversalStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
     /** Contract address of the strategy */
@@ -1052,7 +1072,14 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
      * Calculates the weighted average APY across all pools based on USD value.
      * @returns {Promise<number>} The weighted average APY across all pools
      */
-    netAPY(): Promise<number>;
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    private computeAPY;
     /**
        * Calculates the total TVL of the strategy.
        * @returns Object containing the total amount in token units and USD value
@@ -1062,7 +1089,14 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
         amount: Web3Number;
         usdValue: number;
     }>;
-    getAUM(): Promise<SingleTokenInfo>;
+    getAUM(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: {
+            id: string;
+            aum: Web3Number;
+        }[];
+    }>;
     getVesuAdapters(): VesuAdapter[];
     getVaultPositions(): Promise<VaultPosition[]>;
     getSetManagerCall(strategist: ContractAddr, root?: string): Call;
@@ -1075,8 +1109,20 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
     }): {
         proofs: string[];
         manageCall: ManageCall;
+        step: UNIVERSAL_MANAGE_IDS;
     }[];
     getTag(): string;
+    getVesuHealthFactors(): Promise<number[]>;
+    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
+    private getNewHealthFactor;
+    /**
+     *
+     * @param vesuAdapter
+     * @param currentHf
+     * @param isDeposit if true, attempt by adding collateral, else by repaying
+     * @returns
+     */
+    private getLegRebalanceAmount;
     getVesuMultiplyCall(params: {
         isDeposit: boolean;
         leg1DepositAmount: Web3Number;