@strkfarm/sdk 1.1.8 → 1.1.9

package/dist/index.browser.mjs

@@ -64,6 +64,17 @@ var _Web3Number = class extends BigNumber {
     const answer = _value.greaterThanOrEqualTo(_valueMe) ? _value : _valueMe;
     return this.construct(answer.toString(), this.decimals);
   }
+  abs() {
+    console.warn(`abs: this: ${this}`);
+    return this.construct(Math.abs(this.toNumber()).toFixed(12), this.decimals);
+  }
+  toI129() {
+    const sign = this.isNegative() ? 1 : 0;
+    return {
+      mag: BigInt(this.toWei()) * (this.isNegative() ? -1n : 1n),
+      sign
+    };
+  }
 };
 BigNumber.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN });
 _Web3Number.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN });
@@ -2147,6 +2158,61 @@ var AvnuWrapper = class _AvnuWrapper {
   }
 };
 
+// src/modules/ekubo-quoter.ts
+import axios5 from "axios";
+var EkuboQuoter = class {
+  // e.g. ETH/USDC'
+  constructor(config) {
+    this.config = config;
+    this.ENDPOINT = "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}";
+  }
+  /**
+   * 
+   * @param fromToken 
+   * @param toToken 
+   * @param amount Can be negative too, which would mean to get exact amount out
+   * @returns 
+   */
+  async getQuote(fromToken, toToken, amount) {
+    let _fromToken = amount.gt(0) ? fromToken : toToken;
+    let _toToken = amount.gt(0) ? toToken : fromToken;
+    const quote = await axios5.get(this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", _fromToken).replace("{{TOKEN_TO_ADDRESS}}", _toToken));
+    console.log(`Ekubo quote from ${_fromToken} to ${_toToken} for ${amount.toString()}: ${JSON.stringify(quote.data)}`);
+    return quote.data;
+  }
+  /**
+   * Formats Ekubo response for Vesu multiple use
+   * @param quote 
+   * @param fromTokenInfo 
+   * @returns 
+   */
+  getVesuMultiplyQuote(quote, fromTokenInfo, toTokenInfo) {
+    return quote.splits.map((split) => {
+      const isNegativeAmount = BigInt(split.amount_specified) < 0n;
+      const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
+      return {
+        route: split.route.map((_route) => ({
+          pool_key: {
+            token0: ContractAddr.from(_route.pool_key.token0),
+            token1: ContractAddr.from(_route.pool_key.token1),
+            fee: _route.pool_key.fee,
+            tick_spacing: _route.pool_key.tick_spacing.toString(),
+            extension: _route.pool_key.extension
+          },
+          sqrt_ratio_limit: Web3Number.fromWei(_route.sqrt_ratio_limit, 18),
+          // just for use, any decimal works
+          skip_ahead: Web3Number.fromWei(_route.skip_ahead, 0)
+          // no decimal for this
+        })),
+        token_amount: {
+          token: token.address,
+          amount: Web3Number.fromWei(split.amount_specified, token.decimals)
+        }
+      };
+    });
+  }
+};
+
 // src/interfaces/common.tsx
 import { BlockTag, RpcProvider as RpcProvider2 } from "starknet";
 import { Fragment, jsx } from "react/jsx-runtime";
@@ -3853,9 +3919,9 @@ var BaseStrategy = class extends CacheClass {
 };
 
 // src/node/headless.browser.ts
-import axios5 from "axios";
+import axios6 from "axios";
 async function getAPIUsingHeadlessBrowser(url) {
-  const res = await axios5.get(url);
+  const res = await axios6.get(url);
   return res.data;
 }
 
@@ -16292,20 +16358,27 @@ var _protocol2 = {
   name: "Ekubo",
   logo: "https://app.ekubo.org/favicon.ico"
 };
-var _corelatedPoolRiskFactors = [
+var _lstPoolRiskFactors = [
   { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
   { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 1 /* HIGHLY_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
-  { type: "Market Risk" /* MARKET_RISK */, value: 1 /* VERY_LOW_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
+  { type: "Market Risk" /* MARKET_RISK */, value: 1 /* VERY_LOW_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: "Depeg Risk" /* DEPEG_RISK */, value: 2 /* GENERALLY_STABLE */, weight: 33, reason: "Generally stable pegged assets" }
+];
+var _stableCoinPoolRiskFactors = [
+  { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 1 /* BATTLE_TESTED */, weight: 34, reason: "Audited smart contracts" },
+  { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 1 /* HIGHLY_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: "Market Risk" /* MARKET_RISK */, value: 1 /* VERY_LOW_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" },
+  { type: "Depeg Risk" /* DEPEG_RISK */, value: 1 /* HIGHLY_STABLE */, weight: 33, reason: "Highly stable assets" }
 ];
 var mediumVolatilityPoolRiskFactors = [
   { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
-  { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
-  { type: "Market Risk" /* MARKET_RISK */, value: 3 /* MODERATE_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
+  { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Assets are not correlated, often volatile" },
+  { type: "Market Risk" /* MARKET_RISK */, value: 3 /* MODERATE_VOLATILITY */, weight: 33, reason: "Assets are not correlated, relative volatile can be moderate sometimes" }
 ];
 var highVolatilityPoolRiskFactors = [
   { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
-  { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
-  { type: "Market Risk" /* MARKET_RISK */, value: 4 /* HIGH_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
+  { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Assets are not correlated, often volatile" },
+  { type: "Market Risk" /* MARKET_RISK */, value: 4 /* HIGH_VOLATILITY */, weight: 33, reason: "Assets are not correlated, relative volatile is often high" }
 ];
 var mediumRisk = {
   riskFactor: mediumVolatilityPoolRiskFactors,
@@ -16378,9 +16451,9 @@ var xSTRKSTRK = {
   auditUrl: AUDIT_URL2,
   maxTVL: Web3Number.fromWei("0", 18),
   risk: {
-    riskFactor: _corelatedPoolRiskFactors,
-    netRisk: _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
-    notARisks: getNoRiskTags(_corelatedPoolRiskFactors)
+    riskFactor: _lstPoolRiskFactors,
+    netRisk: _lstPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _lstPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(_lstPoolRiskFactors)
   },
   apyMethodology: "APY based on 30-day historical performance, including fees and rewards.",
   additionalInfo: {
@@ -16535,7 +16608,11 @@ var RE7Strategies = [
       Global.getDefaultTokens().find((t) => t.symbol === "USDC"),
       Global.getDefaultTokens().find((t) => t.symbol === "USDT")
     ],
-    risk: xSTRKSTRK.risk
+    risk: {
+      riskFactor: _stableCoinPoolRiskFactors,
+      netRisk: _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _stableCoinPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_stableCoinPoolRiskFactors)
+    }
   },
   {
     ...ETHUSDCRe7Strategy,
@@ -18719,6 +18796,7 @@ import { hash, num as num6, shortString } from "starknet";
 
 // src/strategies/universal-adapters/adapter-utils.ts
 var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
+var SIMPLE_SANITIZER_V2 = ContractAddr.from("0x5643d54da70a471cd2b6fa37f52ea7a13cc3f3910689a839f8490a663d2208a");
 var PRICE_ROUTER = ContractAddr.from("0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837");
 var AVNU_MIDDLEWARE = ContractAddr.from("0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d");
 function toBigInt(value) {
@@ -18733,13 +18811,13 @@ function toBigInt(value) {
 
 // src/strategies/universal-adapters/baseAdapter.ts
 var BaseAdapter = class extends CacheClass {
-  constructSimpleLeafData(params) {
+  constructSimpleLeafData(params, sanitizer = SIMPLE_SANITIZER) {
     const { id, target, method, packedArguments } = params;
     return {
       id: BigInt(num6.getDecimalString(shortString.encodeShortString(id))),
       readableId: id,
       data: [
-        SIMPLE_SANITIZER.toBigInt(),
+        sanitizer.toBigInt(),
         // sanitizer address
         target.toBigInt(),
         // contract
@@ -21178,172 +21256,833 @@ var vesu_singleton_abi_default = [
   }
 ];
 
-// src/strategies/universal-adapters/vesu-adapter.ts
-var VesuAmountType = /* @__PURE__ */ ((VesuAmountType2) => {
-  VesuAmountType2[VesuAmountType2["Delta"] = 0] = "Delta";
-  VesuAmountType2[VesuAmountType2["Target"] = 1] = "Target";
-  return VesuAmountType2;
-})(VesuAmountType || {});
-var VesuAmountDenomination = /* @__PURE__ */ ((VesuAmountDenomination2) => {
-  VesuAmountDenomination2[VesuAmountDenomination2["Native"] = 0] = "Native";
-  VesuAmountDenomination2[VesuAmountDenomination2["Assets"] = 1] = "Assets";
-  return VesuAmountDenomination2;
-})(VesuAmountDenomination || {});
-var VesuPools = {
-  Genesis: ContractAddr.from("0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28")
-};
-var VesuAdapter = class _VesuAdapter extends BaseAdapter {
-  constructor(config) {
-    super();
-    this.VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
-    this.getModifyPosition = () => {
-      const positionData = [0n];
-      const packedArguments = [
-        toBigInt(this.config.poolId.toString()),
-        // pool id
-        toBigInt(this.config.collateral.address.toString()),
-        // collateral
-        toBigInt(this.config.debt.address.toString()),
-        // debt
-        toBigInt(this.config.vaultAllocator.toString()),
-        // vault allocator
-        toBigInt(positionData.length),
-        ...positionData
-      ];
-      const output = this.constructSimpleLeafData({
-        id: this.config.id,
-        target: this.VESU_SINGLETON,
-        method: "modify_position",
-        packedArguments
-      });
-      return { leaf: output, callConstructor: this.getModifyPositionCall.bind(this) };
-    };
-    this.getModifyPositionCall = (params) => {
-      const _collateral = {
-        amount_type: this.formatAmountTypeEnum(params.collateralAmount.amount_type),
-        denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
-        value: {
-          abs: uint2567.bnToUint256(params.collateralAmount.value.abs.toWei()),
-          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.abs.isZero() ? false : params.debtAmount.value.is_negative
-        }
-      };
-      logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`);
-      const singletonContract = new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider4({ nodeUrl: "" }) });
-      const call = singletonContract.populate("modify_position", {
-        params: {
-          pool_id: this.config.poolId.toBigInt(),
-          collateral_asset: this.config.collateral.address.toBigInt(),
-          debt_asset: this.config.debt.address.toBigInt(),
-          user: this.config.vaultAllocator.toBigInt(),
-          collateral: _collateral,
-          debt: _debt,
-          data: [0]
-        }
-      });
-      return {
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: this.VESU_SINGLETON,
-          selector: hash3.getSelectorFromName("modify_position"),
-          calldata: [
-            ...call.calldata
-          ]
-        }
-      };
-    };
-    this.getDefispringRewardsAdapter = (id) => {
-      return () => {
-        const packedArguments = [];
-        const output = {
-          id: BigInt(num8.getDecimalString(shortString3.encodeShortString(id))),
-          readableId: id,
-          data: [
-            SIMPLE_SANITIZER.toBigInt(),
-            // sanitizer address
-            VESU_REWARDS_CONTRACT.toBigInt(),
-            // contract
-            toBigInt(hash3.getSelectorFromName("claim")),
-            // method name
-            BigInt(packedArguments.length),
-            ...packedArguments
-          ]
-        };
-        return { leaf: output, callConstructor: this.getDefiSpringClaimCall().bind(this) };
-      };
-    };
-    this.getDefiSpringClaimCall = () => {
-      return (params) => ({
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: VESU_REWARDS_CONTRACT,
-          selector: hash3.getSelectorFromName("claim"),
-          calldata: [
-            BigInt(params.amount.toWei()),
-            BigInt(params.proofs.length),
-            ...params.proofs.map((proof) => BigInt(num8.hexToDecimalString(proof)))
-          ]
-        }
-      });
-    };
-    this.config = config;
-  }
-  static getDefaultModifyPositionCallParams(params) {
-    return {
-      collateralAmount: {
-        amount_type: 0 /* Delta */,
-        denomination: 1 /* Assets */,
-        value: {
-          abs: params.collateralAmount,
-          is_negative: !params.isAddCollateral
-        }
+// src/data/vesu-multiple.abi.json
+var vesu_multiple_abi_default = [
+  {
+    type: "impl",
+    name: "LockerImpl",
+    interface_name: "ekubo::interfaces::core::ILocker"
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "ekubo::interfaces::core::ILocker",
+    items: [
+      {
+        type: "function",
+        name: "locked",
+        inputs: [
+          {
+            name: "id",
+            type: "core::integer::u32"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "MultiplyImpl",
+    interface_name: "vesu_periphery::multiply::IMultiply"
+  },
+  {
+    type: "struct",
+    name: "ekubo::types::keys::PoolKey",
+    members: [
+      {
+        name: "token0",
+        type: "core::starknet::contract_address::ContractAddress"
       },
-      debtAmount: {
-        amount_type: 0 /* Delta */,
-        denomination: 1 /* Assets */,
-        value: {
-          abs: params.debtAmount,
-          is_negative: !params.isBorrow
-        }
+      {
+        name: "token1",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "fee",
+        type: "core::integer::u128"
+      },
+      {
+        name: "tick_spacing",
+        type: "core::integer::u128"
+      },
+      {
+        name: "extension",
+        type: "core::starknet::contract_address::ContractAddress"
       }
-    };
-  }
-  formatAmountTypeEnum(amountType) {
-    switch (amountType) {
-      case 0 /* Delta */:
-        return new CairoCustomEnum2({ Delta: {} });
-      case 1 /* Target */:
-        return new CairoCustomEnum2({ Target: {} });
-    }
-    throw new Error(`Unknown VesuAmountType: ${amountType}`);
-  }
-  formatAmountDenominationEnum(denomination) {
-    switch (denomination) {
-      case 0 /* Native */:
-        return new CairoCustomEnum2({ Native: {} });
-      case 1 /* Assets */:
-        return new CairoCustomEnum2({ Assets: {} });
-    }
-    throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
-  }
-  getVesuSingletonContract(config) {
-    return new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider });
-  }
-  async getLTVConfig(config) {
-    const CACHE_KEY = "ltv_config";
-    const cacheData = this.getCache(CACHE_KEY);
-    if (cacheData) {
-      return cacheData;
-    }
-    const output = await this.getVesuSingletonContract(config).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::integer::u256",
+    members: [
+      {
+        name: "low",
+        type: "core::integer::u128"
+      },
+      {
+        name: "high",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::swap::RouteNode",
+    members: [
+      {
+        name: "pool_key",
+        type: "ekubo::types::keys::PoolKey"
+      },
+      {
+        name: "sqrt_ratio_limit",
+        type: "core::integer::u256"
+      },
+      {
+        name: "skip_ahead",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "ekubo::types::i129::i129",
+    members: [
+      {
+        name: "mag",
+        type: "core::integer::u128"
+      },
+      {
+        name: "sign",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::swap::TokenAmount",
+    members: [
+      {
+        name: "token",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "amount",
+        type: "ekubo::types::i129::i129"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::swap::Swap",
+    members: [
+      {
+        name: "route",
+        type: "core::array::Array::<vesu_periphery::swap::RouteNode>"
+      },
+      {
+        name: "token_amount",
+        type: "vesu_periphery::swap::TokenAmount"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::multiply::IncreaseLeverParams",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252"
+      },
+      {
+        name: "collateral_asset",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "debt_asset",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "add_margin",
+        type: "core::integer::u128"
+      },
+      {
+        name: "margin_swap",
+        type: "core::array::Array::<vesu_periphery::swap::Swap>"
+      },
+      {
+        name: "margin_swap_limit_amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "lever_swap",
+        type: "core::array::Array::<vesu_periphery::swap::Swap>"
+      },
+      {
+        name: "lever_swap_limit_amount",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::multiply::DecreaseLeverParams",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252"
+      },
+      {
+        name: "collateral_asset",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "debt_asset",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "sub_margin",
+        type: "core::integer::u128"
+      },
+      {
+        name: "recipient",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "lever_swap",
+        type: "core::array::Array::<vesu_periphery::swap::Swap>"
+      },
+      {
+        name: "lever_swap_limit_amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "lever_swap_weights",
+        type: "core::array::Array::<core::integer::u128>"
+      },
+      {
+        name: "withdraw_swap",
+        type: "core::array::Array::<vesu_periphery::swap::Swap>"
+      },
+      {
+        name: "withdraw_swap_limit_amount",
+        type: "core::integer::u128"
+      },
+      {
+        name: "withdraw_swap_weights",
+        type: "core::array::Array::<core::integer::u128>"
+      },
+      {
+        name: "close_position",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "vesu_periphery::multiply::ModifyLeverAction",
+    variants: [
+      {
+        name: "IncreaseLever",
+        type: "vesu_periphery::multiply::IncreaseLeverParams"
+      },
+      {
+        name: "DecreaseLever",
+        type: "vesu_periphery::multiply::DecreaseLeverParams"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::multiply::ModifyLeverParams",
+    members: [
+      {
+        name: "action",
+        type: "vesu_periphery::multiply::ModifyLeverAction"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "alexandria_math::i257::i257",
+    members: [
+      {
+        name: "abs",
+        type: "core::integer::u256"
+      },
+      {
+        name: "is_negative",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu_periphery::multiply::ModifyLeverResponse",
+    members: [
+      {
+        name: "collateral_delta",
+        type: "alexandria_math::i257::i257"
+      },
+      {
+        name: "debt_delta",
+        type: "alexandria_math::i257::i257"
+      },
+      {
+        name: "margin_delta",
+        type: "alexandria_math::i257::i257"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "vesu_periphery::multiply::IMultiply",
+    items: [
+      {
+        type: "function",
+        name: "modify_lever",
+        inputs: [
+          {
+            name: "modify_lever_params",
+            type: "vesu_periphery::multiply::ModifyLeverParams"
+          }
+        ],
+        outputs: [
+          {
+            type: "vesu_periphery::multiply::ModifyLeverResponse"
+          }
+        ],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "ekubo::interfaces::core::ICoreDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vesu::singleton::ISingletonDispatcher",
+    members: [
+      {
+        name: "contract_address",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "core",
+        type: "ekubo::interfaces::core::ICoreDispatcher"
+      },
+      {
+        name: "singleton",
+        type: "vesu::singleton::ISingletonDispatcher"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "vesu_periphery::multiply::Multiply::IncreaseLever",
+    kind: "struct",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "collateral_asset",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "debt_asset",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "margin",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "collateral_delta",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "debt_delta",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "vesu_periphery::multiply::Multiply::DecreaseLever",
+    kind: "struct",
+    members: [
+      {
+        name: "pool_id",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "collateral_asset",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "debt_asset",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "user",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "margin",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "collateral_delta",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "debt_delta",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "vesu_periphery::multiply::Multiply::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "IncreaseLever",
+        type: "vesu_periphery::multiply::Multiply::IncreaseLever",
+        kind: "nested"
+      },
+      {
+        name: "DecreaseLever",
+        type: "vesu_periphery::multiply::Multiply::DecreaseLever",
+        kind: "nested"
+      }
+    ]
+  }
+];
+
+// src/strategies/universal-adapters/vesu-adapter.ts
+var VesuAmountType = /* @__PURE__ */ ((VesuAmountType2) => {
+  VesuAmountType2[VesuAmountType2["Delta"] = 0] = "Delta";
+  VesuAmountType2[VesuAmountType2["Target"] = 1] = "Target";
+  return VesuAmountType2;
+})(VesuAmountType || {});
+var VesuAmountDenomination = /* @__PURE__ */ ((VesuAmountDenomination2) => {
+  VesuAmountDenomination2[VesuAmountDenomination2["Native"] = 0] = "Native";
+  VesuAmountDenomination2[VesuAmountDenomination2["Assets"] = 1] = "Assets";
+  return VesuAmountDenomination2;
+})(VesuAmountDenomination || {});
+function getVesuMultiplyParams(isIncrease, params) {
+  if (isIncrease) {
+    const _params2 = params;
+    return {
+      action: new CairoCustomEnum2({ IncreaseLever: {
+        pool_id: _params2.pool_id.toBigInt(),
+        collateral_asset: _params2.collateral_asset.toBigInt(),
+        debt_asset: _params2.debt_asset.toBigInt(),
+        user: _params2.user.toBigInt(),
+        add_margin: BigInt(_params2.add_margin.toWei()),
+        margin_swap: _params2.margin_swap.map((swap) => ({
+          route: swap.route.map((route) => ({
+            pool_key: {
+              token0: route.pool_key.token0.toBigInt(),
+              token1: route.pool_key.token1.toBigInt(),
+              fee: route.pool_key.fee,
+              tick_spacing: route.pool_key.tick_spacing,
+              extension: BigInt(num8.hexToDecimalString(route.pool_key.extension))
+            },
+            sqrt_ratio_limit: uint2567.bnToUint256(route.sqrt_ratio_limit.toWei()),
+            skip_ahead: BigInt(100)
+          })),
+          token_amount: {
+            token: swap.token_amount.token.toBigInt(),
+            amount: swap.token_amount.amount.toI129()
+          }
+        })),
+        margin_swap_limit_amount: BigInt(_params2.margin_swap_limit_amount.toWei()),
+        lever_swap: _params2.lever_swap.map((swap) => ({
+          route: swap.route.map((route) => ({
+            pool_key: {
+              token0: route.pool_key.token0.toBigInt(),
+              token1: route.pool_key.token1.toBigInt(),
+              fee: route.pool_key.fee,
+              tick_spacing: route.pool_key.tick_spacing,
+              extension: BigInt(num8.hexToDecimalString(route.pool_key.extension))
+            },
+            sqrt_ratio_limit: uint2567.bnToUint256(route.sqrt_ratio_limit.toWei()),
+            skip_ahead: BigInt(100)
+          })),
+          token_amount: {
+            token: swap.token_amount.token.toBigInt(),
+            amount: swap.token_amount.amount.toI129()
+          }
+        })),
+        lever_swap_limit_amount: BigInt(_params2.lever_swap_limit_amount.toWei())
+      } })
+    };
+  }
+  const _params = params;
+  return {
+    action: new CairoCustomEnum2({ DecreaseLever: {
+      pool_id: _params.pool_id.toBigInt(),
+      collateral_asset: _params.collateral_asset.toBigInt(),
+      debt_asset: _params.debt_asset.toBigInt(),
+      user: _params.user.toBigInt(),
+      sub_margin: BigInt(_params.sub_margin.toWei()),
+      recipient: _params.recipient.toBigInt(),
+      lever_swap: _params.lever_swap.map((swap) => ({
+        route: swap.route.map((route) => ({
+          pool_key: {
+            token0: route.pool_key.token0.toBigInt(),
+            token1: route.pool_key.token1.toBigInt(),
+            fee: route.pool_key.fee,
+            tick_spacing: route.pool_key.tick_spacing,
+            extension: ContractAddr.from(route.pool_key.extension).toBigInt()
+          },
+          sqrt_ratio_limit: uint2567.bnToUint256(route.sqrt_ratio_limit.toWei()),
+          skip_ahead: BigInt(route.skip_ahead.toWei())
+        })),
+        token_amount: {
+          token: swap.token_amount.token.toBigInt(),
+          amount: swap.token_amount.amount.toI129()
+        }
+      })),
+      lever_swap_limit_amount: BigInt(_params.lever_swap_limit_amount.toWei()),
+      lever_swap_weights: _params.lever_swap_weights.map((weight) => BigInt(weight.toWei())),
+      withdraw_swap: _params.withdraw_swap.map((swap) => ({
+        route: swap.route.map((route) => ({
+          pool_key: {
+            token0: route.pool_key.token0.toBigInt(),
+            token1: route.pool_key.token1.toBigInt(),
+            fee: route.pool_key.fee,
+            tick_spacing: route.pool_key.tick_spacing,
+            extension: ContractAddr.from(route.pool_key.extension).toBigInt()
+          },
+          sqrt_ratio_limit: uint2567.bnToUint256(route.sqrt_ratio_limit.toWei()),
+          skip_ahead: BigInt(route.skip_ahead.toWei())
+        })),
+        token_amount: {
+          token: swap.token_amount.token.toBigInt(),
+          amount: swap.token_amount.amount.toI129()
+        }
+      })),
+      withdraw_swap_limit_amount: BigInt(_params.withdraw_swap_limit_amount.toWei()),
+      withdraw_swap_weights: _params.withdraw_swap_weights.map((weight) => BigInt(weight.toWei())),
+      close_position: _params.close_position
+    } })
+  };
+}
+var VesuPools = {
+  Genesis: ContractAddr.from("0x4dc4f0ca6ea4961e4c8373265bfd5317678f4fe374d76f3fd7135f57763bf28"),
+  Re7xSTRK: ContractAddr.from("0x052fb52363939c3aa848f8f4ac28f0a51379f8d1b971d8444de25fbd77d8f161")
+};
+var VesuAdapter = class _VesuAdapter extends BaseAdapter {
+  constructor(config) {
+    super();
+    this.VESU_SINGLETON = ContractAddr.from("0x000d8d6dfec4d33bfb6895de9f3852143a17c6f92fd2a21da3d6924d34870160");
+    this.VESU_MULTIPLY = ContractAddr.from("0x3630f1f8e5b8f5c4c4ae9b6620f8a570ae55cddebc0276c37550e7c118edf67");
+    this.getModifyPosition = () => {
+      const positionData = [0n];
+      const packedArguments = [
+        toBigInt(this.config.poolId.toString()),
+        // pool id
+        toBigInt(this.config.collateral.address.toString()),
+        // collateral
+        toBigInt(this.config.debt.address.toString()),
+        // debt
+        toBigInt(this.config.vaultAllocator.toString()),
+        // vault allocator
+        toBigInt(positionData.length),
+        ...positionData
+      ];
+      const output = this.constructSimpleLeafData({
+        id: this.config.id,
+        target: this.VESU_SINGLETON,
+        method: "modify_position",
+        packedArguments
+      });
+      return { leaf: output, callConstructor: this.getModifyPositionCall.bind(this) };
+    };
+    this.getModifyPositionCall = (params) => {
+      const _collateral = {
+        amount_type: this.formatAmountTypeEnum(params.collateralAmount.amount_type),
+        denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
+        value: {
+          abs: uint2567.bnToUint256(params.collateralAmount.value.abs.toWei()),
+          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.abs.isZero() ? false : params.debtAmount.value.is_negative
+        }
+      };
+      logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`);
+      const singletonContract = new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider4({ nodeUrl: "" }) });
+      const call = singletonContract.populate("modify_position", {
+        params: {
+          pool_id: this.config.poolId.toBigInt(),
+          collateral_asset: this.config.collateral.address.toBigInt(),
+          debt_asset: this.config.debt.address.toBigInt(),
+          user: this.config.vaultAllocator.toBigInt(),
+          collateral: _collateral,
+          debt: _debt,
+          data: [0]
+        }
+      });
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: this.VESU_SINGLETON,
+          selector: hash3.getSelectorFromName("modify_position"),
+          calldata: [
+            ...call.calldata
+          ]
+        }
+      };
+    };
+    this.getMultiplyAdapter = () => {
+      const packedArguments = [
+        toBigInt(this.config.poolId.toString()),
+        // pool id
+        toBigInt(this.config.collateral.address.toString()),
+        // collateral
+        toBigInt(this.config.debt.address.toString()),
+        // debt
+        toBigInt(this.config.vaultAllocator.toString())
+        // vault allocator
+      ];
+      const output = this.constructSimpleLeafData({
+        id: this.config.id,
+        target: this.VESU_MULTIPLY,
+        method: "modify_lever",
+        packedArguments
+      }, SIMPLE_SANITIZER_V2);
+      return { leaf: output, callConstructor: this.getMultiplyCall.bind(this) };
+    };
+    this.getMultiplyCall = (params) => {
+      const isIncrease = params.isIncrease;
+      const multiplyParams = isIncrease ? params.increaseParams : params.decreaseParams;
+      if (!multiplyParams) {
+        throw new Error("Multiply params are not provided");
+      }
+      const multiplyContract = new Contract8({ abi: vesu_multiple_abi_default, address: this.VESU_MULTIPLY.toString(), providerOrAccount: new RpcProvider4({ nodeUrl: "" }) });
+      const call = multiplyContract.populate("modify_lever", {
+        modify_lever_params: getVesuMultiplyParams(isIncrease, {
+          ...multiplyParams,
+          user: this.config.vaultAllocator,
+          pool_id: this.config.poolId,
+          collateral_asset: this.config.collateral.address,
+          debt_asset: this.config.debt.address,
+          recipient: this.config.vaultAllocator
+        })
+      });
+      return {
+        sanitizer: SIMPLE_SANITIZER_V2,
+        call: {
+          contractAddress: this.VESU_MULTIPLY,
+          selector: hash3.getSelectorFromName("modify_lever"),
+          calldata: [
+            ...call.calldata
+          ]
+        }
+      };
+    };
+    this.getVesuModifyDelegationAdapter = (id) => {
+      return () => {
+        const packedArguments = [
+          toBigInt(this.config.poolId.toString()),
+          // pool id
+          toBigInt(this.VESU_MULTIPLY.toString())
+          // vault allocator
+        ];
+        const output = this.constructSimpleLeafData({
+          id,
+          target: this.VESU_SINGLETON,
+          method: "modify_delegation",
+          packedArguments
+        }, SIMPLE_SANITIZER_V2);
+        return { leaf: output, callConstructor: this.getVesuModifyDelegationCall.bind(this) };
+      };
+    };
+    this.getVesuModifyDelegationCall = (params) => {
+      const singletonContract = new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.toString(), providerOrAccount: new RpcProvider4({ nodeUrl: "" }) });
+      const call = singletonContract.populate("modify_delegation", {
+        pool_id: this.config.poolId.toBigInt(),
+        delegatee: this.VESU_MULTIPLY.toBigInt(),
+        delegation: params.delegation
+      });
+      return {
+        sanitizer: SIMPLE_SANITIZER_V2,
+        call: {
+          contractAddress: this.VESU_SINGLETON,
+          selector: hash3.getSelectorFromName("modify_delegation"),
+          calldata: [
+            ...call.calldata
+          ]
+        }
+      };
+    };
+    this.getDefispringRewardsAdapter = (id) => {
+      return () => {
+        const packedArguments = [];
+        const output = {
+          id: BigInt(num8.getDecimalString(shortString3.encodeShortString(id))),
+          readableId: id,
+          data: [
+            SIMPLE_SANITIZER.toBigInt(),
+            // sanitizer address
+            VESU_REWARDS_CONTRACT.toBigInt(),
+            // contract
+            toBigInt(hash3.getSelectorFromName("claim")),
+            // method name
+            BigInt(packedArguments.length),
+            ...packedArguments
+          ]
+        };
+        return { leaf: output, callConstructor: this.getDefiSpringClaimCall().bind(this) };
+      };
+    };
+    this.getDefiSpringClaimCall = () => {
+      return (params) => ({
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: VESU_REWARDS_CONTRACT,
+          selector: hash3.getSelectorFromName("claim"),
+          calldata: [
+            BigInt(params.amount.toWei()),
+            BigInt(params.proofs.length),
+            ...params.proofs.map((proof) => BigInt(num8.hexToDecimalString(proof)))
+          ]
+        }
+      });
+    };
+    this.config = config;
+  }
+  static getDefaultModifyPositionCallParams(params) {
+    return {
+      collateralAmount: {
+        amount_type: 0 /* Delta */,
+        denomination: 1 /* Assets */,
+        value: {
+          abs: params.collateralAmount,
+          is_negative: !params.isAddCollateral
+        }
+      },
+      debtAmount: {
+        amount_type: 0 /* Delta */,
+        denomination: 1 /* Assets */,
+        value: {
+          abs: params.debtAmount,
+          is_negative: !params.isBorrow
+        }
+      }
+    };
+  }
+  formatAmountTypeEnum(amountType) {
+    switch (amountType) {
+      case 0 /* Delta */:
+        return new CairoCustomEnum2({ Delta: {} });
+      case 1 /* Target */:
+        return new CairoCustomEnum2({ Target: {} });
+    }
+    throw new Error(`Unknown VesuAmountType: ${amountType}`);
+  }
+  formatAmountDenominationEnum(denomination) {
+    switch (denomination) {
+      case 0 /* Native */:
+        return new CairoCustomEnum2({ Native: {} });
+      case 1 /* Assets */:
+        return new CairoCustomEnum2({ Assets: {} });
+    }
+    throw new Error(`Unknown VesuAmountDenomination: ${denomination}`);
+  }
+  getVesuSingletonContract(config) {
+    return new Contract8({ abi: vesu_singleton_abi_default, address: this.VESU_SINGLETON.address, providerOrAccount: config.provider });
+  }
+  async getLTVConfig(config) {
+    const CACHE_KEY = "ltv_config";
+    const cacheData = this.getCache(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
+    }
+    const output = await this.getVesuSingletonContract(config).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
     this.setCache(CACHE_KEY, Number(output.max_ltv) / 1e18, 3e5);
     return this.getCache(CACHE_KEY);
   }
@@ -23683,10 +24422,10 @@ var vault_manager_abi_default = [
 
 // src/strategies/universal-strategy.tsx
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-var AUMTypes = /* @__PURE__ */ ((AUMTypes2) => {
-  AUMTypes2["FINALISED"] = "finalised";
-  AUMTypes2["DEFISPRING"] = "defispring";
-  return AUMTypes2;
+var AUMTypes = /* @__PURE__ */ ((AUMTypes3) => {
+  AUMTypes3["FINALISED"] = "finalised";
+  AUMTypes3["DEFISPRING"] = "defispring";
+  return AUMTypes3;
 })(AUMTypes || {});
 var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   constructor(config, pricer, metadata) {
@@ -23814,24 +24553,33 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
    * @returns {Promise<number>} The weighted average APY across all pools
    */
   async netAPY() {
-    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
-    const pools = await VesuAdapter.getVesuPools();
-    const pool1 = pools.pools.find((p) => vesuAdapter1.config.poolId.eqString(num9.getHexString(p.id)));
-    const pool2 = pools.pools.find((p) => vesuAdapter2.config.poolId.eqString(num9.getHexString(p.id)));
-    if (!pool1 || !pool2) {
+    const prevAUM = await this.getPrevAUM();
+    const vesuAdapters = this.getVesuAdapters();
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const pools = vesuAdapters.map((vesuAdapter) => {
+      return allVesuPools.pools.find((p) => vesuAdapter.config.poolId.eqString(num9.getHexString(p.id)));
+    });
+    logger.verbose(`${this.metadata.name}::netAPY: vesu-pools: ${JSON.stringify(pools)}`);
+    if (pools.some((p) => !p)) {
       throw new Error("Pool not found");
     }
     ;
-    const collateralAsset1 = pool1.assets.find((a) => a.symbol === vesuAdapter1.config.collateral.symbol)?.stats;
-    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;
-    const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
-    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18;
-    const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
-    const positions = await this.getVaultPositions();
+    const positions = await this.getVesuPositions();
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    const baseAPYs = [];
+    const rewardAPYs = [];
+    for (const [index, pool] of pools.entries()) {
+      const vesuAdapter = vesuAdapters[index];
+      const collateralAsset = pool.assets.find((a) => a.symbol === vesuAdapter.config.collateral.symbol)?.stats;
+      const debtAsset = pool.assets.find((a) => a.symbol === vesuAdapter.config.debt.symbol)?.stats;
+      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+      const lstAPY = Number(collateralAsset.lstApr?.value || 0) / 1e18;
+      baseAPYs.push(...[supplyApy + lstAPY, Number(debtAsset.borrowApr.value) / 1e18]);
+      rewardAPYs.push(...[Number(collateralAsset.defiSpringSupplyApr.value || "0") / 1e18, 0]);
+    }
+    logger.verbose(`${this.metadata.name}::netAPY: baseAPYs: ${JSON.stringify(baseAPYs)}`);
+    logger.verbose(`${this.metadata.name}::netAPY: rewardAPYs: ${JSON.stringify(rewardAPYs)}`);
+    assert(baseAPYs.length == positions.length, "APYs and positions length mismatch");
     if (positions.every((p) => p.amount.isZero())) {
       return { net: 0, splits: [{
         apy: 0,
@@ -23842,11 +24590,10 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       }] };
     }
     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 price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const prevAUMUSD = prevAUM.multipliedBy(price.price);
+    const baseAPY = this.computeAPY(baseAPYs, weights, prevAUMUSD);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights, prevAUMUSD);
     const netAPY = baseAPY + rewardAPY;
     logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
     return { net: netAPY, splits: [{
@@ -23857,11 +24604,11 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       id: "defispring"
     }] };
   }
-  computeAPY(apys, weights) {
+  computeAPY(apys, weights, currentAUM) {
     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;
+    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
+    return weightedSum / currentAUM.toNumber();
   }
   /**
      * Calculates the total TVL of the strategy.
@@ -23893,24 +24640,48 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       usdValue
     };
   }
-  async getAUM() {
+  async getVesuAUM(adapter) {
+    const legAUM = await adapter.getPositions(this.config);
+    const underlying = this.asset();
+    let vesuAum = Web3Number.fromWei("0", underlying.decimals);
+    if (legAUM[0].token.address.eq(underlying.address)) {
+      vesuAum = vesuAum.plus(legAUM[0].amount);
+    } else {
+      const tokenPrice = await this.pricer.getPrice(legAUM[1].token.symbol);
+      vesuAum = vesuAum.plus(legAUM[1].usdValue / tokenPrice.price);
+    }
+    if (legAUM[1].token.address.eq(underlying.address)) {
+      vesuAum = vesuAum.minus(legAUM[1].amount);
+    } else {
+      const tokenPrice = await this.pricer.getPrice(legAUM[1].token.symbol);
+      vesuAum = vesuAum.minus(legAUM[1].usdValue / tokenPrice.price);
+    }
+    ;
+    logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);
+    return vesuAum;
+  }
+  async getPrevAUM() {
     const currentAUM = await this.contract.call("aum", []);
-    const lastReportTime = await this.contract.call("last_report_timestamp", []);
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    logger.verbose(`${this.getTag()} Prev AUM: ${prevAum}`);
+    return prevAum;
+  }
+  async getAUM() {
+    const prevAum = await this.getPrevAUM();
     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 vesuAdapters = this.getVesuAdapters();
+    let vesuAum = Web3Number.fromWei("0", this.asset().decimals);
+    for (const adapter of vesuAdapters) {
+      vesuAum = vesuAum.plus(await this.getVesuAUM(adapter));
+    }
     const balance = await this.getUnusedBalance();
     logger.verbose(`${this.getTag()} unused balance: ${balance.amount.toNumber()}`);
-    const vesuAum = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount);
-    logger.verbose(`${this.getTag()} Vesu AUM: leg1: ${leg1AUM[0].amount.toNumber()}, ${leg1AUM[1].amount.toNumber()}, leg2: ${leg2AUM[0].amount.toNumber()}, ${leg2AUM[1].amount.toNumber()}`);
     const zeroAmt = Web3Number.fromWei("0", this.asset().decimals);
     const net = {
       tokenInfo: this.asset(),
       amount: zeroAmt,
       usdValue: 0
     };
-    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
     if (vesuAum.isZero()) {
       return { net, splits: [{
         aum: zeroAmt,
@@ -23922,16 +24693,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     }
     const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
-    const netAPY = await this.netAPY();
-    const defispringAPY = (netAPY.splits.find((s) => s.id === "defispring")?.apy || 0) * 0.8;
-    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 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 rewardAssets = await this.getRewardsAUM(prevAum);
     const newAUM = aumToken.plus(rewardAssets);
     logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
     net.amount = newAUM;
@@ -23945,6 +24707,21 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     }];
     return { net, splits, prevAum };
   }
+  // account for future rewards (e.g. defispring rewards)
+  async getRewardsAUM(prevAum) {
+    const lastReportTime = await this.contract.call("last_report_timestamp", []);
+    const netAPY = await this.netAPY();
+    const defispringAPY = (netAPY.splits.find((s) => s.id === "defispring")?.apy || 0) * 0.8;
+    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 rewardAssets = prevAum.multipliedBy(growthRate);
+    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
+    logger.verbose(`${this.getTag()} Current AUM: ${prevAum.toString()}`);
+    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
+    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+    return rewardAssets;
+  }
   getVesuAdapters() {
     const vesuAdapter1 = this.getAdapter("vesu_leg1_adapter" /* VESU_LEG1 */);
     const vesuAdapter2 = this.getAdapter("vesu_leg2_adapter" /* VESU_LEG2 */);
@@ -23954,11 +24731,23 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     vesuAdapter2.networkConfig = this.config;
     return [vesuAdapter1, vesuAdapter2];
   }
+  async getVesuPositions() {
+    const adapters = this.getVesuAdapters();
+    const positions = [];
+    for (const adapter of adapters) {
+      positions.push(...await adapter.getPositions(this.config));
+    }
+    return positions;
+  }
   async getVaultPositions() {
-    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
-    const leg1Positions = await vesuAdapter1.getPositions(this.config);
-    const leg2Positions = await vesuAdapter2.getPositions(this.config);
-    return [...leg1Positions, ...leg2Positions];
+    const vesuPositions = await this.getVesuPositions();
+    const unusedBalance = await this.getUnusedBalance();
+    return [...vesuPositions, {
+      amount: unusedBalance.amount,
+      usdValue: unusedBalance.usdValue,
+      token: this.asset(),
+      remarks: "Unused Balance"
+    }];
   }
   getSetManagerCall(strategist, root = this.getMerkleRoot()) {
     return this.managerContract.populate("set_manage_root", [strategist.address, num9.getHexString(root)]);
@@ -24096,7 +24885,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       return new Web3Number(newAmount.toFixed(8), debtTokenAmount.decimals);
     }
   }
-  async getVesuMultiplyCall(params) {
+  async getVesuModifyPositionCall(params) {
     const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const leg1LTV = await vesuAdapter1.getLTVConfig(this.config);
     const leg2LTV = await vesuAdapter2.getLTVConfig(this.config);
@@ -24596,6 +25385,336 @@ var UniversalStrategies = [
     investmentSteps
   }
 ];
+
+// src/strategies/universal-lst-muliplier-strategy.tsx
+import { Contract as Contract10, uint256 as uint2569 } from "starknet";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var UniversalLstMultiplierStrategy = class extends UniversalStrategy {
+  constructor(config, pricer, metadata) {
+    super(config, pricer, metadata);
+    this.quoteAmountToFetchPrice = new Web3Number(1, 18);
+    const STRKToken = Global.getDefaultTokens().find((token) => token.symbol === "STRK");
+    const underlyingToken = this.getLSTUnderlyingTokenInfo();
+    if (underlyingToken.address.eq(STRKToken.address)) {
+      this.quoteAmountToFetchPrice = new Web3Number(100, 18);
+    } else {
+      this.quoteAmountToFetchPrice = new Web3Number(0.01, this.asset().decimals);
+    }
+  }
+  // only one leg is used
+  // todo support lending assets of underlying as well
+  getVesuAdapters() {
+    const vesuAdapter1 = this.getAdapter("vesu_leg1_adapter" /* VESU_LEG1 */);
+    vesuAdapter1.pricer = this.pricer;
+    vesuAdapter1.networkConfig = this.config;
+    return [vesuAdapter1];
+  }
+  // not applicable for this strategy
+  // No rewards on collateral or borrowing of LST assets
+  async getRewardsAUM(prevAum) {
+    return Web3Number.fromWei("0", this.asset().decimals);
+  }
+  async getLSTDexPrice() {
+    const ekuboQuoter = new EkuboQuoter(this.config);
+    const lstTokenInfo = this.asset();
+    const lstUnderlyingTokenInfo = this.getLSTUnderlyingTokenInfo();
+    const quote = await ekuboQuoter.getQuote(
+      lstTokenInfo.address.address,
+      lstUnderlyingTokenInfo.address.address,
+      this.quoteAmountToFetchPrice
+    );
+    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
+    const price = outputAmount.toNumber() / this.quoteAmountToFetchPrice.toNumber();
+    logger.verbose(`${this.getTag()}:: LST Dex Price: ${price}`);
+    return price;
+  }
+  /**
+   * Uses vesu's multiple call to create leverage on LST
+   * Deposit amount is in LST
+   * @param params 
+   */
+  async getVesuMultiplyCall(params) {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    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()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+    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 addedCollateral = params.leg1DepositAmount.multipliedBy(params.isDeposit ? 1 : -1);
+    const DEXPrice = await this.getLSTDexPrice();
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
+    const numeratorPart1 = existingCollateralInfo.amount.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(legLTV);
+    const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
+    const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - legLTV / DEXPrice;
+    const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
+    logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
+    const debtAmount = x_debt_usd.dividedBy(debtPrice);
+    const marginAmount = addedCollateral;
+    logger.verbose(`${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+    return this.getModifyLeverCall({
+      marginAmount,
+      debtAmount,
+      isIncrease: debtAmount.greaterThan(0)
+    });
+  }
+  getLSTUnderlyingTokenInfo() {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    return vesuAdapter1.config.debt;
+  }
+  async getLSTExchangeRate() {
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const lstTokenInfo = vesuAdapter1.config.collateral;
+    const lstABI = new Contract10({
+      abi: erc4626_abi_default,
+      address: lstTokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+    const price = await lstABI.call("convert_to_assets", [uint2569.bnToUint256(new Web3Number(1, lstTokenInfo.decimals).toWei())]);
+    const exchangeRate = Number(uint2569.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
+    logger.verbose(`${this.getTag()}:: LST Exchange Rate: ${exchangeRate}`);
+    return exchangeRate;
+  }
+  /**
+   * 
+   * @param params marginAmount is in LST, debtAmount is in underlying
+   */
+  async getModifyLeverCall(params) {
+    assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), "Deposit/debt must be non-0");
+    const [vesuAdapter1] = this.getVesuAdapters();
+    const lstTokenInfo = this.asset();
+    const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
+    const proofsIDs = [];
+    const manageCalls = [];
+    if (params.marginAmount.greaterThan(0)) {
+      const STEP1_ID = "approve_token1" /* APPROVE_TOKEN1 */;
+      const manage1Info = this.getProofs(STEP1_ID);
+      const depositAmount = params.marginAmount;
+      const manageCall1 = manage1Info.callConstructor({
+        amount: depositAmount
+      });
+      proofsIDs.push(STEP1_ID);
+      manageCalls.push(manageCall1);
+    }
+    const ekuboQuoter = new EkuboQuoter(this.config);
+    const lstPrice = await this.getLSTExchangeRate();
+    const marginSwap = [];
+    const MAX_SLIPPAGE = 0.01;
+    const fromToken = params.isIncrease ? lstUnderlyingTokenInfo : lstTokenInfo;
+    const toToken = params.isIncrease ? lstTokenInfo : lstUnderlyingTokenInfo;
+    const leverSwapQuote = await ekuboQuoter.getQuote(
+      fromToken.address.address,
+      toToken.address.address,
+      params.debtAmount
+      // negative for exact amount out
+    );
+    assert(leverSwapQuote.price_impact < MAX_SLIPPAGE, "getIncreaseLeverCall: Price impact is too high [Debt swap]");
+    const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
+    const minExpectedDebt = params.debtAmount.dividedBy(lstPrice).multipliedBy(1 - MAX_SLIPPAGE);
+    const maxUsedCollateral = params.debtAmount.abs().dividedBy(lstPrice).multipliedBy(1 + MAX_SLIPPAGE);
+    const STEP2_ID = "switch_delegation_on" /* SWITCH_DELEGATION_ON */;
+    const manage2Info = this.getProofs(STEP2_ID);
+    const manageCall2 = manage2Info.callConstructor({
+      delegation: true
+    });
+    const STEP3_ID = "multiply_vesu" /* MULTIPLY_VESU */;
+    const manage3Info = this.getProofs(STEP3_ID);
+    const multiplyParams = params.isIncrease ? {
+      isIncrease: true,
+      increaseParams: {
+        add_margin: params.marginAmount,
+        margin_swap: marginSwap,
+        margin_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: minExpectedDebt
+      }
+    } : {
+      isIncrease: false,
+      decreaseParams: {
+        sub_margin: params.marginAmount.multipliedBy(-1),
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: maxUsedCollateral,
+        // only required for close position
+        lever_swap_weights: [],
+        // no need to swap collateral to anything, and any residuals return our contract anyways. 
+        withdraw_swap: [],
+        withdraw_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
+        withdraw_swap_weights: [],
+        close_position: false
+      }
+    };
+    const manageCall3 = manage3Info.callConstructor(multiplyParams);
+    const STEP4_ID = "switch_delegation_off" /* SWITCH_DELEGATION_OFF */;
+    const manage4Info = this.getProofs(STEP4_ID);
+    const manageCall4 = manage4Info.callConstructor({
+      delegation: false
+    });
+    proofsIDs.push(STEP2_ID, STEP3_ID, STEP4_ID);
+    manageCalls.push(manageCall2, manageCall3, manageCall4);
+    return [this.getManageCall(proofsIDs, manageCalls)];
+  }
+};
+function VaultDescription() {
+  const containerStyle = {
+    maxWidth: "800px",
+    margin: "0 auto",
+    backgroundColor: "#111",
+    color: "#eee",
+    fontFamily: "Arial, sans-serif",
+    borderRadius: "12px"
+  };
+  return /* @__PURE__ */ jsxs4("div", { style: containerStyle, children: [
+    /* @__PURE__ */ jsx5("h1", { style: { fontSize: "18px", marginBottom: "10px" }, children: "Meta Vault \u2014 Automated Yield Router" }),
+    /* @__PURE__ */ jsx5("p", { style: { fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }, children: "This Levered Endur LST vault is a tokenized leveraged Vault, auto-compounding strategy that continuously allocates your deposited asset to the best available yield source in the ecosystem. Depositors receive vault shares that represent a proportional claim on the underlying assets and accrued yield. Allocation shifts are handled programmatically based on on-chain signals and risk filters, minimizing idle capital and maximizing net APY." }),
+    /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
+      /* @__PURE__ */ jsx5("strong", { children: "Withdrawals:" }),
+      " Requests can take up to ",
+      /* @__PURE__ */ jsx5("strong", { children: "1-2 hours" }),
+      " to process as the vault unwinds and settles routing."
+    ] }) })
+  ] });
+}
+function getDescription2(tokenSymbol) {
+  return VaultDescription();
+}
+function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1) {
+  vaultSettings.leafAdapters = [];
+  const lstToken = Global.getDefaultTokens().find((token) => token.symbol === lstSymbol);
+  const underlyingToken = Global.getDefaultTokens().find((token) => token.symbol === underlyingSymbol);
+  const vesuAdapterLST = new VesuAdapter({
+    poolId: pool1,
+    collateral: lstToken,
+    debt: underlyingToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: "multiply_vesu" /* MULTIPLY_VESU */
+  });
+  const commonAdapter = new CommonAdapter({
+    manager: vaultSettings.manager,
+    asset: lstToken.address,
+    id: "",
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator
+  });
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vesuAdapterLST.VESU_MULTIPLY, "approve_token1" /* APPROVE_TOKEN1 */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter.bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_on" /* SWITCH_DELEGATION_ON */).bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_off" /* SWITCH_DELEGATION_OFF */).bind(vesuAdapterLST));
+  vaultSettings.adapters.push(...[{
+    id: "vesu_leg1_adapter" /* VESU_LEG1 */,
+    adapter: vesuAdapterLST
+  }, {
+    id: "common_adapter" /* COMMON */,
+    adapter: commonAdapter
+  }]);
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter("defispring_rewards" /* DEFISPRING_REWARDS */).bind(vesuAdapterLST));
+  const STRKToken = Global.getDefaultTokens().find((token) => token.symbol === "STRK");
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, "approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, "avnu_swap_rewards" /* AVNU_SWAP_REWARDS */).bind(commonAdapter));
+  return vaultSettings;
+}
+function getFAQs2(lstSymbol, underlyingSymbol) {
+  return [
+    {
+      question: `What is the Hyper ${lstSymbol} Vault?`,
+      answer: `The Hyper ${lstSymbol} Vault is a tokenized strategy that automatically loops your ${underlyingSymbol} or ${lstSymbol} to create up to 4x leverage to hence yield in a very low risk manner.`
+    },
+    {
+      question: "How does yield allocation work?",
+      answer: `The strategy uses deposited ${lstSymbol} to collateralize it on Vesu, borrow more ${underlyingSymbol} to loop further. Instead of manually doing this, using flash loan, this leverage is created in a single gas efficient step. Our continuous monitoring systems gauge current yield and available liquidity in real time to make sure yield is optimal. For instance, if the looping becomes in-efficient in future, the strategy will rebalance to reduce leverage or simply hold ${lstSymbol} to continue earning yield.`
+    },
+    {
+      question: "Which protocols/dApp are used??",
+      answer: /* @__PURE__ */ jsxs4("span", { children: [
+        "Currently, the LST is from ",
+        /* @__PURE__ */ jsx5("strong", { children: "Endur" }),
+        " while ",
+        /* @__PURE__ */ jsx5("strong", { children: "Vesu" }),
+        " is used to collateralize the looped position."
+      ] })
+    },
+    {
+      question: "Can I get liquidated?",
+      answer: "The strategy uses highly correlated assets which drastically reduces the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep."
+    },
+    {
+      question: "What do I receive when I deposit?",
+      answer: "Depositors receive vault tokens representing their proportional share of the vault. These tokens entitle holders to both the principal and accrued yield."
+    },
+    {
+      question: "How long do withdrawals take?",
+      answer: "Withdrawals may take up to 1-2 hours to process, as the vault unwinds and settles liquidity routing across integrated protocols. In case of large withdrawals, to avoid slippage, we may slowly unwind the position, which could make the withdrawals longer."
+    },
+    {
+      question: "Is the Hyper xSTRK Vault non-custodial?",
+      answer: "Yes. The Hyper xSTRK Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent."
+    },
+    {
+      question: "Is the Vault audited?",
+      answer: "Yes. The Hyper xSTRK Vault is audited by Zellic. Look for safety icon beside the strategy name for more details."
+    },
+    {
+      question: "Are there any fees?",
+      answer: "Troves charges a performance of 10% on the yield generated. The APY shown is net of this fee. This fee is only applied to the profits earned, ensuring that users retain their initial capital."
+    }
+  ];
+}
+var _riskFactor4 = [
+  { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 25, reason: "Audited by Zellic" },
+  { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 1 /* VERY_LOW_PROBABILITY */, weight: 50, reason: "The collateral and debt are highly correlated" },
+  { type: "Technical Risk" /* TECHNICAL_RISK */, value: 1 /* STABLE_INFRASTRUCTURE */, weight: 50, reason: "Liquidation can only happen if vault is left un-monitored for weeks, which is highly unlikely. We actively monitor all services on a daily basis." }
+];
+var hyperxSTRK = {
+  vaultAddress: ContractAddr.from("0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960"),
+  manager: ContractAddr.from("0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a"),
+  vaultAllocator: ContractAddr.from("0x511d07953a09bc7c505970891507c5a2486d2ea22752601a14db092186d7caa"),
+  redeemRequestNFT: ContractAddr.from("0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095"),
+  aumOracle: ContractAddr.from("0x48cf709870a1a0d453d37de108e0c41b8b89819ef54f95abc0e2e1f98bbe937"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05
+};
+function getInvestmentSteps(lstSymbol, underlyingSymbol) {
+  return [
+    `Deposit ${underlyingSymbol} into the vault`,
+    `The vault manager loops the ${underlyingSymbol} to buy ${lstSymbol}`,
+    `The vault manager collateralizes the ${lstSymbol} on Vesu`,
+    `The vault manager borrows more ${underlyingSymbol} to loop further`,
+    `Claim BTCFi STRK rewards weekly to swap to ${lstSymbol} and reinvest`,
+    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
+  ];
+}
+function getStrategySettings(lstSymbol, underlyingSymbol, addresses) {
+  return {
+    name: `Hyper ${lstSymbol}`,
+    description: getDescription2(lstSymbol),
+    address: addresses.vaultAddress,
+    launchBlock: 0,
+    type: "Other",
+    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === lstSymbol)],
+    additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7xSTRK),
+    risk: {
+      riskFactor: _riskFactor4,
+      netRisk: _riskFactor4.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor4.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor4)
+    },
+    protocols: [Protocols.ENDUR, Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 18),
+    contractDetails: getContractDetails(addresses),
+    faqs: getFAQs2(lstSymbol, underlyingSymbol),
+    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol)
+  };
+}
+var HyperLSTStrategies = [
+  getStrategySettings("xSTRK", "STRK", hyperxSTRK)
+];
 export {
   AUMTypes,
   AutoCompounderSTRK,
@@ -24607,9 +25726,11 @@ export {
   ERC20,
   EkuboCLVault,
   EkuboCLVaultStrategies,
+  EkuboQuoter,
   FatalError,
   FlowChartColors,
   Global,
+  HyperLSTStrategies,
   ILending,
   Initializable,
   MarginType,
@@ -24623,6 +25744,7 @@ export {
   SenseiVault,
   UNIVERSAL_ADAPTERS,
   UNIVERSAL_MANAGE_IDS,
+  UniversalLstMultiplierStrategy,
   UniversalStrategies,
   UniversalStrategy,
   VesuAdapter,
@@ -24633,6 +25755,7 @@ export {
   VesuRebalanceStrategies,
   Web3Number,
   ZkLend,
+  getContractDetails,
   getMainnetConfig,
   getNoRiskTags,
   getRiskColor,