@strkfarm/sdk 1.0.56 → 1.0.58

package/dist/index.browser.global.js

@@ -27510,19 +27510,19 @@ ${r2}}` : "}", l2;
         }
       };
       exports.InvariantError = InvariantError;
-      var InvalidArgumentError2 = class extends Error {
+      var InvalidArgumentError = class extends Error {
         constructor(message) {
           super(message);
           this.name = "InvalidArgumentError";
         }
       };
-      exports.InvalidArgumentError = InvalidArgumentError2;
-      function validateArgument2(condition, message) {
+      exports.InvalidArgumentError = InvalidArgumentError;
+      function validateArgument(condition, message) {
         if (!condition) {
-          throw new InvalidArgumentError2(message);
+          throw new InvalidArgumentError(message);
         }
       }
-      exports.validateArgument = validateArgument2;
+      exports.validateArgument = validateArgument;
       function invariant(condition, message) {
         if (!condition) {
           throw new InvariantError(message);
@@ -49908,19 +49908,6 @@ ${indent}}` : "}";
   var import_hashes = __toESM(require_hashes());
   var import_merkletree = __toESM(require_merkletree());
 
-  // node_modules/.pnpm/@ericnordelo+strk-merkle-tree@1.0.0/node_modules/@ericnordelo/strk-merkle-tree/src/utils/errors.ts
-  var InvalidArgumentError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "InvalidArgumentError";
-    }
-  };
-  function validateArgument(condition, message) {
-    if (!condition) {
-      throw new InvalidArgumentError(message);
-    }
-  }
-
   // ../node_modules/@noble/hashes/esm/_assert.js
   function number3(n) {
     if (!Number.isSafeInteger(n) || n < 0)
@@ -51975,13 +51962,6 @@ ${indent}}` : "}";
       });
       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 (0, import_bytes.toHex)(root) === (0, import_core.processProof)((0, import_hashes.standardLeafHash)(leafEncoding, leaf), proof);
     }
@@ -53734,23 +53714,10 @@ ${indent}}` : "}";
     }
   ];
 
-  // src/strategies/base-strategy.ts
-  var BaseStrategy = class {
-    constructor(config2) {
+  // src/utils/cacheClass.ts
+  var CacheClass = class {
+    constructor() {
       this.cache = /* @__PURE__ */ new Map();
-      this.config = config2;
-    }
-    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();
@@ -53771,6 +53738,27 @@ ${indent}}` : "}";
     }
   };
 
+  // src/strategies/base-strategy.ts
+  var BaseStrategy = class extends CacheClass {
+    constructor(config2) {
+      super();
+      this.cache = /* @__PURE__ */ new Map();
+      this.config = config2;
+    }
+    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
   async function getAPIUsingHeadlessBrowser(url) {
     const res = await axios_default.get(url);
@@ -68232,9 +68220,8 @@ ${indent}}` : "}";
     }
     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}`
       );
@@ -68278,9 +68265,8 @@ ${indent}}` : "}";
     }
     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,
@@ -68431,7 +68417,7 @@ ${indent}}` : "}";
   }
 
   // src/strategies/universal-adapters/baseAdapter.ts
-  var BaseAdapter = class {
+  var BaseAdapter = class extends CacheClass {
     constructSimpleLeafData(params) {
       const { id, target, method, packedArguments } = params;
       return {
@@ -70802,7 +70788,6 @@ ${indent}}` : "}";
     constructor(config2) {
       super();
       this.VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
-      this.cache = {};
       this.getModifyPosition = () => {
         const positionData = [0n];
         const packedArguments = [
@@ -70831,17 +70816,19 @@ ${indent}}` : "}";
           denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
           value: {
             abs: uint256_exports.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: uint256_exports.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 Contract(vesu_singleton_abi_default, this.VESU_SINGLETON.toString(), new RpcProvider2({ nodeUrl: "" }));
         const call = singletonContract.populate("modify_position", {
           params: {
@@ -70910,20 +70897,22 @@ ${indent}}` : "}";
     }
     async getLTVConfig(config2) {
       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 output4 = await this.getVesuSingletonContract(config2).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
-      this.cache[CACHE_KEY] = Number(output4.max_ltv) / 1e18;
-      return this.cache[CACHE_KEY];
+      this.setCache(CACHE_KEY, Number(output4.max_ltv) / 1e18, 3e5);
+      return this.getCache(CACHE_KEY);
     }
     async getPositions(config2) {
       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 output4 = await this.getVesuSingletonContract(config2).call("position_unsafe", [
         this.config.poolId.address,
@@ -70946,9 +70935,65 @@ ${indent}}` : "}";
         usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
         remarks: "Debt"
       }];
-      this.cache[CACHE_KEY] = value;
+      this.setCache(CACHE_KEY, value, 6e4);
       return value;
     }
+    async getCollateralization(config2) {
+      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 output4 = await this.getVesuSingletonContract(config2).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(output4["1"].toString(), 18);
+      const debtAmount = Web3Number.fromWei(output4["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 output4 = await Promise.all([collateralizationProm, positionsProm, ltvProm]);
+      const [collateralization, positions, ltv] = output4;
+      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);
@@ -73317,19 +73362,32 @@ ${indent}}` : "}";
       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();
-      assert3(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];
+      assert3(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) {
+      assert3(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.
@@ -73352,22 +73410,50 @@ ${indent}}` : "}";
       };
     }
     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 {
+      const balance = await new ERC20(this.config).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+      logger.verbose(`${this.getTag()} unused balance: ${balance}`);
+      const aumToken = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount).plus(balance);
+      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() {
@@ -73409,12 +73495,14 @@ ${indent}}` : "}";
       }));
       const output4 = [{
         proofs: manage5Info.proofs,
-        manageCall: manageCall5
+        manageCall: manageCall5,
+        step: STEP2_ID
       }];
       if (approveAmount.gt(0)) {
         output4.unshift({
           proofs: manage4Info.proofs,
-          manageCall: manageCall4
+          manageCall: manageCall4,
+          step: STEP1_ID
         });
       }
       return output4;
@@ -73422,9 +73510,96 @@ ${indent}}` : "}";
     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);
+        assert3(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);
+        assert3(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);
+      }
+      assert3(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}`);
@@ -73433,7 +73608,7 @@ ${indent}}` : "}";
       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(
@@ -73491,14 +73666,14 @@ ${indent}}` : "}";
       });
       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;
       }
@@ -73565,15 +73740,21 @@ ${indent}}` : "}";
     manager: ContractAddr.from("0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07"),
     vaultAllocator: ContractAddr.from("0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba"),
     redeemRequestNFT: ContractAddr.from("0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda"),
+    aumOracle: ContractAddr.from("0x6faf45ed185dec13ef723c9ead4266cab98d06f2cb237e331b1fa5c2aa79afe"),
     leafAdapters: [],
-    adapters: []
+    adapters: [],
+    targetHealthFactor: 1.3,
+    minHealthFactor: 1.25
   };
   var wbtcVaultSettings = {
     manager: ContractAddr.from("0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34"),
     vaultAllocator: ContractAddr.from("0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735"),
     redeemRequestNFT: ContractAddr.from("0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2"),
+    aumOracle: ContractAddr.from("0x2edf4edbed3f839e7f07dcd913e92299898ff4cf0ba532f8c572c66c5b331b2"),
     leafAdapters: [],
-    adapters: []
+    adapters: [],
+    targetHealthFactor: 1.3,
+    minHealthFactor: 1.25
   };
   var UniversalStrategies = [
     {