@strkfarm/sdk 1.0.56 → 1.0.57

package/dist/index.mjs

@@ -1986,7 +1986,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
@@ -4044,13 +4043,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);
   }
@@ -5808,23 +5800,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();
@@ -5845,6 +5824,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) {
@@ -20318,9 +20318,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}`
     );
@@ -20364,9 +20363,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,
@@ -20520,7 +20518,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 {
@@ -22895,7 +22893,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 = [
@@ -22924,17 +22921,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: {
@@ -23003,20 +23002,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,
@@ -23039,9 +23040,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);
@@ -25413,19 +25470,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.
@@ -25448,22 +25518,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() {
@@ -25505,12 +25601,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;
@@ -25518,9 +25616,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}`);
@@ -25529,7 +25714,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(
@@ -25587,14 +25772,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;
     }
@@ -25662,14 +25847,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 = [
   {
@@ -25719,13 +25908,10 @@ var TelegramNotif = class {
     this.subscribers = [
       // '6820228303',
       "1505578076",
-      // '5434736198', // maaza
       "1356705582",
       // langs
       "1388729514",
       // hwashere
-      "6020162572",
-      //minato
       "985902592"
     ];
     this.bot = new TelegramBot(token, { polling: shouldPoll });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.56",
+  "version": "1.0.57",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/notifs/telegram.ts

@@ -5,10 +5,8 @@ export class TelegramNotif {
     private subscribers: string[] = [
         // '6820228303',
         '1505578076',
-        // '5434736198', // maaza
         '1356705582', // langs
         '1388729514', // hwashere
-        '6020162572', //minato
         '985902592'
     ];
     readonly bot: TelegramBot;

package/src/strategies/base-strategy.ts

@@ -1,5 +1,6 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo } from "@/interfaces";
+import { CacheClass } from "@/utils/cacheClass";
 import { Call } from "starknet";
 
 export interface SingleActionAmount {
@@ -26,11 +27,12 @@ interface CacheData {
   ttl: number;
   data: any;
 }
-export class BaseStrategy<TVLInfo, ActionInfo> {
+export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     readonly config: IConfig;
     readonly cache: Map<string, CacheData> = new Map();
 
     constructor(config: IConfig) {
+        super();
         this.config = config;
     }
 
@@ -49,26 +51,4 @@ export class BaseStrategy<TVLInfo, ActionInfo> {
     async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
-
-    setCache(key: string, data: any, ttl: number = 60000): void {
-        const timestamp = Date.now();
-        this.cache.set(key, { timestamp, ttl, data });
-    }
-
-    getCache(key: string): any | null {
-        const cachedData = this.cache.get(key);
-        if (!cachedData || !this.isCacheValid(key)) {
-            return null;
-        }
-        return cachedData.data;
-    }
-
-    isCacheValid(key: string): boolean {
-        const cachedData = this.cache.get(key);
-        if (!cachedData) return false;
-
-        const { timestamp, ttl } = cachedData;
-        return Date.now() - timestamp <= ttl;
-    }
-    
 }

package/src/strategies/sensei.ts

@@ -126,9 +126,16 @@ export class SenseiVault extends BaseStrategy<
     collateralInSTRK: number;
   }> {
     const CACHE_KEY = 'positionInfo';
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache<{
+      collateralXSTRK: Web3Number;
+      collateralUSDValue: Web3Number;
+      debtSTRK: Web3Number;
+      debtUSDValue: Web3Number;
+      xSTRKPrice: number;
+      collateralInSTRK: number;
+    }>(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
+
     const resp = await fetch(
       `${getTrovesEndpoint()}/vesu/positions?walletAddress=${this.address.address}`,
     );
@@ -179,9 +186,9 @@ export class SenseiVault extends BaseStrategy<
 
    async getSecondaryTokenPriceRelativeToMain(retry = 0): Promise<number> {
     const CACHE_KEY = 'xSTRKPrice';
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache<number>(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
+    
     const params: QuoteRequest = {
       sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
       buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -2,6 +2,7 @@ import { Call, hash, num, shortString } from "starknet";
 import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
 import { ContractAddr } from "@/dataTypes";
 import { LeafData } from "@/utils";
+import { CacheClass } from "@/utils/cacheClass";
 
 export interface ManageCall {
   sanitizer: ContractAddr,
@@ -16,7 +17,7 @@ export type GenerateCallFn<T> = (params: T) => ManageCall;
 export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
 export type LeafAdapterFn<T> = () => AdapterLeafType<T>;
 
-export class BaseAdapter {
+export class BaseAdapter extends CacheClass {
 
   protected constructSimpleLeafData(params: {
     id: string,