@strkfarm/sdk 2.0.0-dev.34 → 2.0.0-dev.35

package/dist/index.mjs

@@ -21734,6 +21734,7 @@ import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract10, hash as ha
 
 // src/strategies/universal-adapters/adapter-utils.ts
 var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
+var SVK_SIMPLE_SANITIZER = ContractAddr.from("0x03dcde04343257c3ce14574676cb9c5b2eda16e332c1b8caf5dc4c95ac568d2f");
 var EXTENDED_SANITIZER = ContractAddr.from("0x65891708362b24dcf4c40c8e218cce6e82d1d6b3a3404c9ab00a48f08e2c110");
 var AVNU_LEGACY_SANITIZER = ContractAddr.from("0x0656fBE853f116DD53956176a553eDe8fE65632252f8aceB50C1B9B6c8237309");
 var SIMPLE_SANITIZER_V2 = ContractAddr.from("0x7b6f98311af8aa425278570e62abf523e6462eaa01a38c1feab9b2f416492e2");
@@ -35597,7 +35598,14 @@ var VesuModifyPositionAdapter = class _VesuModifyPositionAdapter extends BaseAda
     }
     const normalizedDebtAmount = this._normalizeDebtAmountFromHelper(
       helperOutput
-    );
+    ).minus(state.currentDebt);
+    if (normalizedDebtAmount.lessThan(0)) {
+      logger.warn(`VesuModifyPositionAdapter: deposit debt delta is negative (${normalizedDebtAmount.toNumber()}), clamping to zero`);
+      return {
+        collateral: this._toSigned(collateralToAdd, false),
+        debt: this._toSigned(Web3Number.fromWei(0, this.config.debt.decimals), false)
+      };
+    }
     return {
       collateral: this._toSigned(collateralToAdd, false),
       debt: this._toSigned(normalizedDebtAmount, false)
@@ -35615,8 +35623,8 @@ var VesuModifyPositionAdapter = class _VesuModifyPositionAdapter extends BaseAda
       state.debtPrice,
       this.config.debt
     );
-    if (!helperOutput || helperOutput.greaterThan(0)) {
-      throw new Error(`Failed to calculate default withdraw debt delta: ${helperOutput?.toNumber()}`);
+    if (!helperOutput || helperOutput.lessThan(0)) {
+      throw new Error(`Failed to calculate max debt amount for withdraw: ${helperOutput?.toNumber()}`);
     }
     const normalizedDebtAmount = this._normalizeDebtAmountFromHelper(
       helperOutput
@@ -35813,6 +35821,24 @@ var VesuModifyPositionAdapter = class _VesuModifyPositionAdapter extends BaseAda
     this._prepareVesuAdapter();
     return this._vesuAdapter.getHealthFactor();
   }
+  /**
+   * Simulates a deposit of `depositAmount` collateral and returns how much
+   * debt (STRK) would be incrementally borrowed to reach the target LTV.
+   * Used upstream to size the AVNU swap call in the same transaction batch.
+   */
+  async getExpectedDepositDebtDelta(depositAmount) {
+    const defaults = await this._buildDefaultDepositDeltas({ amount: depositAmount });
+    return defaults.debt.amount;
+  }
+  /**
+   * Simulates a withdrawal of `withdrawAmount` collateral and returns the
+   * incremental debt delta needed to keep the target health factor.
+   * Positive means borrow, negative means repay.
+   */
+  async getExpectedWithdrawDebtDelta(withdrawAmount) {
+    const defaults = await this._buildDefaultWithdrawDeltas({ amount: withdrawAmount });
+    return defaults.debt.amount;
+  }
 };
 
 // src/strategies/universal-adapters/extended-adapter.ts
@@ -36370,6 +36396,25 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       return { success: false, data: [] };
     }
   }
+  /** Account funding payment history via `GET /api/v1/account/funding-payments` (USDC amounts). */
+  async getFundingPayments(side, startTime, limit) {
+    try {
+      const response = await this.client.getUserFundingPayments(
+        this.config.extendedMarketName,
+        side,
+        startTime ?? Date.now() - 30 * 24 * 60 * 60 * 1e3,
+        limit ?? 200
+      );
+      if (response.status !== "OK") {
+        logger.error("error getting funding payments", response.data);
+        return { success: false, data: [] };
+      }
+      return { success: true, data: response.data ?? [] };
+    } catch (err) {
+      logger.error("error getting funding payments", err);
+      return { success: false, data: [] };
+    }
+  }
   async getPosition(supportedPosition) {
     const holdings = await this.getExtendedDepositAmount();
     if (!holdings) {
@@ -39009,349 +39054,110 @@ var universal_vault_abi_default = [
   }
 ];
 
-// src/strategies/universal-adapters/svk-troves-adapter.ts
-var DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
-function parseTrovesApyField(raw) {
-  if (typeof raw === "number" && Number.isFinite(raw)) {
-    return raw;
-  }
-  if (typeof raw === "string") {
-    const n = Number.parseFloat(raw);
-    if (Number.isFinite(n)) {
-      return n;
-    }
-  }
-  return 0;
-}
-var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
-  constructor(config) {
-    super(config, _SvkTrovesAdapter.name, Protocols.TROVES);
-    this.config = config;
-  }
-  /** Owner used for share balance + `due_assets_from_owner`. */
-  _positionOwner() {
-    return this.config.positionOwner ?? this.config.vaultAllocator;
-  }
-  /**
-   * Proof readable IDs must stay ≤ 31 chars (Cairo short string). We derive a short ASCII suffix from
-   * `strategyVault` address so multiple SVK adapters in one tree stay distinct.
-   */
-  _proofSuffix() {
-    return this.config.strategyVault.address.replace(/^0x/, "").slice(-6);
-  }
-  _depositApproveProofReadableId() {
-    return `appr_dep_svk_${this._proofSuffix()}`;
-  }
-  _depositCallProofReadableId() {
-    return `dep_svk_${this._proofSuffix()}`;
-  }
-  _withdrawCallProofReadableId() {
-    return `wtdrw_svk_${this._proofSuffix()}`;
-  }
-  async getAPY(supportedPosition) {
-    const CACHE_KEY = `svk_apy_${this.config.trovesStrategyId}`;
-    const cached = this.getCache(CACHE_KEY);
-    if (cached) {
-      return cached;
-    }
-    const url = this.config.trovesStrategiesApiUrl ?? DEFAULT_TROVES_STRATEGIES_API;
-    try {
-      const res = await fetch(url);
-      if (!res.ok) {
-        logger.warn(`${_SvkTrovesAdapter.name}::getAPY: HTTP ${res.status} from ${url}`);
-        const fallback = { apy: 0, type: "base" /* BASE */ };
-        this.setCache(CACHE_KEY, fallback, 3e5);
-        return fallback;
-      }
-      const body = await res.json();
-      const row = body.strategies?.find((s) => s.id === this.config.trovesStrategyId);
-      if (!row) {
-        logger.warn(
-          `${_SvkTrovesAdapter.name}::getAPY: strategy id not found: ${this.config.trovesStrategyId}`
-        );
-        const fallback = { apy: 0, type: "base" /* BASE */ };
-        this.setCache(CACHE_KEY, fallback, 3e5);
-        return fallback;
-      }
-      const apy = parseTrovesApyField(row.apy);
-      const result = { apy, type: "base" /* BASE */ };
-      this.setCache(CACHE_KEY, result, 3e5);
-      return result;
-    } catch (error) {
-      logger.error(`${_SvkTrovesAdapter.name}::getAPY:`, error);
-      throw error;
-    }
-  }
-  async getPosition(supportedPosition) {
-    const CACHE_KEY = `svk_pos_${this.config.strategyVault.address}_${this._positionOwner().address}`;
-    const cached = this.getCache(CACHE_KEY);
-    if (cached) {
-      return cached;
-    }
-    try {
-      const vault = new Contract14({
-        abi: universal_vault_abi_default,
-        address: this.config.strategyVault.address,
-        providerOrAccount: this.config.networkConfig.provider
-      });
-      const owner = this._positionOwner();
-      const decimals = supportedPosition.asset.decimals;
-      const shares = await vault.balance_of(owner.address);
-      const shareU256 = uint25619.bnToUint256(shares);
-      const liquidAssetsRaw = await vault.convert_to_assets(shareU256);
-      const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
-      let pending = Web3Number.fromWei("0", decimals);
-      try {
-        const dueRaw = await vault.call("due_assets_from_owner", [owner.address]);
-        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
-      } catch (e) {
-        logger.warn(
-          `${_SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${e.message}`
-        );
-      }
-      const total = liquid.plus(pending);
-      const remarks = `Troves ${this.config.trovesStrategyId} holdings`;
-      const result = {
-        amount: total,
-        remarks
-      };
-      this.setCache(CACHE_KEY, result, 6e4);
-      return result;
-    } catch (error) {
-      logger.error(`${_SvkTrovesAdapter.name}::getPosition:`, error);
-      throw error;
-    }
-  }
-  async maxDeposit(amount) {
-    const baseToken = this.config.baseToken;
-    if (!amount) {
-      return {
-        tokenInfo: baseToken,
-        amount: new Web3Number("999999999999999999999999999", baseToken.decimals),
-        usdValue: 1e27,
-        remarks: "Max deposit (unbounded placeholder)",
-        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-        protocol: this.protocol
-      };
-    }
-    const usdValue = await this.getUSDValue(baseToken, amount);
-    return {
-      tokenInfo: baseToken,
-      amount,
-      usdValue,
-      remarks: "Deposit amount",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-      protocol: this.protocol
-    };
-  }
-  async maxWithdraw() {
-    const baseToken = this.config.baseToken;
-    const current = await this.getPosition({ asset: baseToken, isDebt: false });
-    const pos = current ?? { amount: new Web3Number("0", baseToken.decimals), remarks: "" };
-    const usdValue = await this.getUSDValue(baseToken, pos.amount);
-    return {
-      tokenInfo: baseToken,
-      amount: pos.amount,
-      usdValue,
-      remarks: "Max withdraw (liquid + pending redemption, underlying units)",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-      protocol: this.protocol
-    };
-  }
-  _getDepositLeaf() {
-    const baseToken = this.config.baseToken;
-    const strategyVault = this.config.strategyVault;
-    const receiver = this.config.vaultAllocator;
-    return [
+// src/data/redeem-request-nft.abi.json
+var redeem_request_nft_abi_default = [
+  {
+    type: "impl",
+    name: "RedeemRequestImpl",
+    interface_name: "vault::redeem_request::interface::IRedeemRequest"
+  },
+  {
+    type: "struct",
+    name: "core::integer::u256",
+    members: [
       {
-        target: baseToken.address,
-        method: "approve",
-        packedArguments: [strategyVault.toBigInt()],
-        sanitizer: SIMPLE_SANITIZER,
-        id: this._depositApproveProofReadableId()
+        name: "low",
+        type: "core::integer::u128"
       },
       {
-        target: strategyVault,
-        method: "deposit",
-        packedArguments: [receiver.toBigInt()],
-        sanitizer: SIMPLE_SANITIZER,
-        id: this._depositCallProofReadableId()
-      }
-    ];
-  }
-  _getWithdrawLeaf() {
-    const strategyVault = this.config.strategyVault;
-    const recv = this.config.vaultAllocator;
-    const owner = this.config.vaultAllocator;
-    return [
-      {
-        target: strategyVault,
-        method: "withdraw",
-        packedArguments: [recv.toBigInt(), owner.toBigInt()],
-        sanitizer: SIMPLE_SANITIZER,
-        id: this._withdrawCallProofReadableId()
+        name: "high",
+        type: "core::integer::u128"
       }
-    ];
-  }
-  getDepositAdapter() {
-    const leafConfigs = this._getDepositLeaf();
-    const leaves = leafConfigs.map((config) => {
-      const { target, method, packedArguments, sanitizer, id } = config;
-      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
-    });
-    return { leaves, callConstructor: this.getDepositCall.bind(this) };
-  }
-  getWithdrawAdapter() {
-    const leafConfigs = this._getWithdrawLeaf();
-    const leaves = leafConfigs.map((config) => {
-      const { target, method, packedArguments, sanitizer, id } = config;
-      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
-    });
-    return { leaves, callConstructor: this.getWithdrawCall.bind(this) };
-  }
-  async getDepositCall(params) {
-    const baseToken = this.config.baseToken;
-    const strategyVault = this.config.strategyVault;
-    const amount = params.amount;
-    const uint256Amount = uint25619.bnToUint256(amount.toWei());
-    const receiver = this.config.vaultAllocator;
-    return [
+    ]
+  },
+  {
+    type: "struct",
+    name: "vault::redeem_request::interface::RedeemRequestInfo",
+    members: [
       {
-        proofReadableId: this._depositApproveProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: baseToken.address,
-          selector: hash11.getSelectorFromName("approve"),
-          calldata: [
-            strategyVault.toBigInt(),
-            toBigInt(uint256Amount.low.toString()),
-            toBigInt(uint256Amount.high.toString())
-          ]
-        }
+        name: "epoch",
+        type: "core::integer::u256"
       },
       {
-        proofReadableId: this._depositCallProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: strategyVault,
-          selector: hash11.getSelectorFromName("deposit"),
-          calldata: [
-            toBigInt(uint256Amount.low.toString()),
-            toBigInt(uint256Amount.high.toString()),
-            receiver.toBigInt()
-          ]
-        }
-      }
-    ];
-  }
-  async getWithdrawCall(params) {
-    const strategyVault = this.config.strategyVault;
-    const amount = params.amount;
-    const uint256Amount = uint25619.bnToUint256(amount.toWei());
-    const recv = this.config.vaultAllocator;
-    const owner = this.config.vaultAllocator;
-    return [
-      {
-        proofReadableId: this._withdrawCallProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: strategyVault,
-          selector: hash11.getSelectorFromName("withdraw"),
-          calldata: [
-            toBigInt(uint256Amount.low.toString()),
-            toBigInt(uint256Amount.high.toString()),
-            recv.toBigInt(),
-            owner.toBigInt()
-          ]
-        }
+        name: "nominal",
+        type: "core::integer::u256"
       }
-    ];
-  }
-  getHealthFactor() {
-    return Promise.resolve(10);
-  }
-};
-
-// src/strategies/universal-strategy.tsx
-import { CallData, Contract as Contract15, num as num12, uint256 as uint25620 } from "starknet";
-
-// src/data/vault-manager.abi.json
-var vault_manager_abi_default = [
-  {
-    type: "impl",
-    name: "UpgradeableImpl",
-    interface_name: "openzeppelin_upgrades::interface::IUpgradeable"
+    ]
   },
   {
     type: "interface",
-    name: "openzeppelin_upgrades::interface::IUpgradeable",
+    name: "vault::redeem_request::interface::IRedeemRequest",
     items: [
       {
         type: "function",
-        name: "upgrade",
-        inputs: [
+        name: "vault",
+        inputs: [],
+        outputs: [
           {
-            name: "new_class_hash",
-            type: "core::starknet::class_hash::ClassHash"
+            type: "core::starknet::contract_address::ContractAddress"
           }
         ],
-        outputs: [],
-        state_mutability: "external"
-      }
-    ]
-  },
-  {
-    type: "impl",
-    name: "ManagerFlashloanReceiverImpl",
-    interface_name: "vault_allocator::integration_interfaces::vesu::IFlashloanReceiver"
-  },
-  {
-    type: "struct",
-    name: "core::integer::u256",
-    members: [
-      {
-        name: "low",
-        type: "core::integer::u128"
+        state_mutability: "view"
       },
       {
-        name: "high",
-        type: "core::integer::u128"
-      }
-    ]
-  },
-  {
-    type: "struct",
-    name: "core::array::Span::<core::felt252>",
-    members: [
+        type: "function",
+        name: "id_to_info",
+        inputs: [
+          {
+            name: "id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "vault::redeem_request::interface::RedeemRequestInfo"
+          }
+        ],
+        state_mutability: "view"
+      },
       {
-        name: "snapshot",
-        type: "@core::array::Array::<core::felt252>"
-      }
-    ]
-  },
-  {
-    type: "interface",
-    name: "vault_allocator::integration_interfaces::vesu::IFlashloanReceiver",
-    items: [
+        type: "function",
+        name: "id_len",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
       {
         type: "function",
-        name: "on_flash_loan",
+        name: "mint",
         inputs: [
           {
-            name: "sender",
+            name: "to",
             type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "asset",
-            type: "core::starknet::contract_address::ContractAddress"
-          },
+            name: "redeem_request_info",
+            type: "vault::redeem_request::interface::RedeemRequestInfo"
+          }
+        ],
+        outputs: [
           {
-            name: "amount",
             type: "core::integer::u256"
-          },
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "burn",
+        inputs: [
           {
-            name: "data",
-            type: "core::array::Span::<core::felt252>"
+            name: "id",
+            type: "core::integer::u256"
           }
         ],
         outputs: [],
@@ -39361,26 +39167,39 @@ var vault_manager_abi_default = [
   },
   {
     type: "impl",
-    name: "ManagerImpl",
-    interface_name: "vault_allocator::manager::interface::IManager"
+    name: "UpgradeableImpl",
+    interface_name: "openzeppelin_interfaces::upgrades::IUpgradeable"
   },
   {
-    type: "struct",
-    name: "core::array::Span::<core::array::Span::<core::felt252>>",
-    members: [
+    type: "interface",
+    name: "openzeppelin_interfaces::upgrades::IUpgradeable",
+    items: [
       {
-        name: "snapshot",
-        type: "@core::array::Array::<core::array::Span::<core::felt252>>"
+        type: "function",
+        name: "upgrade",
+        inputs: [
+          {
+            name: "new_class_hash",
+            type: "core::starknet::class_hash::ClassHash"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
       }
     ]
   },
+  {
+    type: "impl",
+    name: "ERC721MixinImpl",
+    interface_name: "openzeppelin_interfaces::token::erc721::ERC721ABI"
+  },
   {
     type: "struct",
-    name: "core::array::Span::<core::starknet::contract_address::ContractAddress>",
+    name: "core::array::Span::<core::felt252>",
     members: [
       {
         name: "snapshot",
-        type: "@core::array::Array::<core::starknet::contract_address::ContractAddress>"
+        type: "@core::array::Array::<core::felt252>"
       }
     ]
   },
@@ -39398,25 +39217,53 @@ var vault_manager_abi_default = [
       }
     ]
   },
+  {
+    type: "struct",
+    name: "core::byte_array::ByteArray",
+    members: [
+      {
+        name: "data",
+        type: "core::array::Array::<core::bytes_31::bytes31>"
+      },
+      {
+        name: "pending_word",
+        type: "core::felt252"
+      },
+      {
+        name: "pending_word_len",
+        type: "core::integer::u32"
+      }
+    ]
+  },
   {
     type: "interface",
-    name: "vault_allocator::manager::interface::IManager",
+    name: "openzeppelin_interfaces::token::erc721::ERC721ABI",
     items: [
       {
         type: "function",
-        name: "vesu_singleton",
-        inputs: [],
-        outputs: [
+        name: "balance_of",
+        inputs: [
           {
+            name: "account",
             type: "core::starknet::contract_address::ContractAddress"
           }
         ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
         state_mutability: "view"
       },
       {
         type: "function",
-        name: "vault_allocator",
-        inputs: [],
+        name: "owner_of",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
         outputs: [
           {
             type: "core::starknet::contract_address::ContractAddress"
@@ -39426,15 +39273,23 @@ var vault_manager_abi_default = [
       },
       {
         type: "function",
-        name: "set_manage_root",
+        name: "safe_transfer_from",
         inputs: [
           {
-            name: "target",
+            name: "from",
             type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "root",
-            type: "core::felt252"
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
           }
         ],
         outputs: [],
@@ -39442,137 +39297,150 @@ var vault_manager_abi_default = [
       },
       {
         type: "function",
-        name: "manage_root",
+        name: "transfer_from",
         inputs: [
           {
-            name: "target",
+            name: "from",
             type: "core::starknet::contract_address::ContractAddress"
-          }
-        ],
-        outputs: [
+          },
           {
-            type: "core::felt252"
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
           }
         ],
-        state_mutability: "view"
+        outputs: [],
+        state_mutability: "external"
       },
       {
         type: "function",
-        name: "pause",
-        inputs: [],
+        name: "approve",
+        inputs: [
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
         outputs: [],
         state_mutability: "external"
       },
       {
         type: "function",
-        name: "unpause",
-        inputs: [],
+        name: "set_approval_for_all",
+        inputs: [
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "approved",
+            type: "core::bool"
+          }
+        ],
         outputs: [],
         state_mutability: "external"
       },
       {
         type: "function",
-        name: "manage_vault_with_merkle_verification",
+        name: "get_approved",
         inputs: [
           {
-            name: "proofs",
-            type: "core::array::Span::<core::array::Span::<core::felt252>>"
-          },
-          {
-            name: "decoder_and_sanitizers",
-            type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
-          },
-          {
-            name: "targets",
-            type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
-          },
-          {
-            name: "selectors",
-            type: "core::array::Span::<core::felt252>"
-          },
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
           {
-            name: "calldatas",
-            type: "core::array::Span::<core::array::Span::<core::felt252>>"
+            type: "core::starknet::contract_address::ContractAddress"
           }
         ],
-        outputs: [],
-        state_mutability: "external"
+        state_mutability: "view"
       },
       {
         type: "function",
-        name: "flash_loan",
+        name: "is_approved_for_all",
         inputs: [
           {
-            name: "recipient",
+            name: "owner",
             type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "asset",
+            name: "operator",
             type: "core::starknet::contract_address::ContractAddress"
-          },
-          {
-            name: "amount",
-            type: "core::integer::u256"
-          },
+          }
+        ],
+        outputs: [
           {
-            name: "is_legacy",
             type: "core::bool"
-          },
-          {
-            name: "data",
-            type: "core::array::Span::<core::felt252>"
           }
         ],
-        outputs: [],
-        state_mutability: "external"
+        state_mutability: "view"
       },
       {
         type: "function",
-        name: "get_leaf_hash",
+        name: "supports_interface",
         inputs: [
           {
-            name: "decoder_and_sanitizer",
-            type: "core::starknet::contract_address::ContractAddress"
-          },
-          {
-            name: "target",
-            type: "core::starknet::contract_address::ContractAddress"
-          },
-          {
-            name: "selector",
+            name: "interface_id",
             type: "core::felt252"
-          },
+          }
+        ],
+        outputs: [
           {
-            name: "packed_argument_addresses",
-            type: "core::array::Span::<core::felt252>"
+            type: "core::bool"
           }
         ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "name",
+        inputs: [],
         outputs: [
           {
-            type: "core::felt252"
+            type: "core::byte_array::ByteArray"
           }
         ],
         state_mutability: "view"
-      }
-    ]
-  },
-  {
-    type: "impl",
-    name: "AccessControlImpl",
-    interface_name: "openzeppelin_access::accesscontrol::interface::IAccessControl"
-  },
-  {
-    type: "interface",
-    name: "openzeppelin_access::accesscontrol::interface::IAccessControl",
-    items: [
+      },
       {
         type: "function",
-        name: "has_role",
+        name: "symbol",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "token_uri",
         inputs: [
           {
-            name: "role",
-            type: "core::felt252"
-          },
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "balanceOf",
+        inputs: [
           {
             name: "account",
             type: "core::starknet::contract_address::ContractAddress"
@@ -39580,38 +39448,46 @@ var vault_manager_abi_default = [
         ],
         outputs: [
           {
-            type: "core::bool"
+            type: "core::integer::u256"
           }
         ],
         state_mutability: "view"
       },
       {
         type: "function",
-        name: "get_role_admin",
+        name: "ownerOf",
         inputs: [
           {
-            name: "role",
-            type: "core::felt252"
+            name: "tokenId",
+            type: "core::integer::u256"
           }
         ],
         outputs: [
           {
-            type: "core::felt252"
+            type: "core::starknet::contract_address::ContractAddress"
           }
         ],
         state_mutability: "view"
       },
       {
         type: "function",
-        name: "grant_role",
+        name: "safeTransferFrom",
         inputs: [
           {
-            name: "role",
-            type: "core::felt252"
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "account",
+            name: "to",
             type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
           }
         ],
         outputs: [],
@@ -39619,15 +39495,19 @@ var vault_manager_abi_default = [
       },
       {
         type: "function",
-        name: "revoke_role",
+        name: "transferFrom",
         inputs: [
           {
-            name: "role",
-            type: "core::felt252"
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "account",
+            name: "to",
             type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
           }
         ],
         outputs: [],
@@ -39635,188 +39515,246 @@ var vault_manager_abi_default = [
       },
       {
         type: "function",
-        name: "renounce_role",
+        name: "setApprovalForAll",
         inputs: [
           {
-            name: "role",
-            type: "core::felt252"
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
           },
           {
-            name: "account",
-            type: "core::starknet::contract_address::ContractAddress"
+            name: "approved",
+            type: "core::bool"
           }
         ],
         outputs: [],
         state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "getApproved",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "isApprovedForAll",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "operator",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tokenURI",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
       }
     ]
   },
   {
     type: "impl",
-    name: "PausableImpl",
-    interface_name: "openzeppelin_security::interface::IPausable"
+    name: "ERC721EnumerableImpl",
+    interface_name: "openzeppelin_interfaces::token::erc721::IERC721Enumerable"
   },
   {
     type: "interface",
-    name: "openzeppelin_security::interface::IPausable",
+    name: "openzeppelin_interfaces::token::erc721::IERC721Enumerable",
     items: [
       {
         type: "function",
-        name: "is_paused",
+        name: "total_supply",
         inputs: [],
         outputs: [
           {
-            type: "core::bool"
+            type: "core::integer::u256"
           }
         ],
         state_mutability: "view"
-      }
-    ]
-  },
-  {
-    type: "constructor",
-    name: "constructor",
-    inputs: [
-      {
-        name: "owner",
-        type: "core::starknet::contract_address::ContractAddress"
-      },
-      {
-        name: "vault_allocator",
-        type: "core::starknet::contract_address::ContractAddress"
       },
       {
-        name: "vesu_singleton",
-        type: "core::starknet::contract_address::ContractAddress"
+        type: "function",
+        name: "token_by_index",
+        inputs: [
+          {
+            name: "index",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "token_of_owner_by_index",
+        inputs: [
+          {
+            name: "owner",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "index",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
       }
     ]
   },
   {
-    type: "event",
-    name: "openzeppelin_introspection::src5::SRC5Component::Event",
-    kind: "enum",
-    variants: []
-  },
-  {
-    type: "event",
-    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGranted",
-    kind: "struct",
-    members: [
-      {
-        name: "role",
-        type: "core::felt252",
-        kind: "data"
-      },
+    type: "constructor",
+    name: "constructor",
+    inputs: [
       {
-        name: "account",
-        type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress"
       },
       {
-        name: "sender",
-        type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        name: "vault",
+        type: "core::starknet::contract_address::ContractAddress"
       }
     ]
   },
   {
     type: "event",
-    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGrantedWithDelay",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
     kind: "struct",
     members: [
       {
-        name: "role",
-        type: "core::felt252",
-        kind: "data"
-      },
-      {
-        name: "account",
+        name: "from",
         type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        kind: "key"
       },
       {
-        name: "sender",
+        name: "to",
         type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        kind: "key"
       },
       {
-        name: "delay",
-        type: "core::integer::u64",
-        kind: "data"
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
       }
     ]
   },
   {
     type: "event",
-    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleRevoked",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
     kind: "struct",
     members: [
       {
-        name: "role",
-        type: "core::felt252",
-        kind: "data"
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
       },
       {
-        name: "account",
+        name: "approved",
         type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        kind: "key"
       },
       {
-        name: "sender",
-        type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
       }
     ]
   },
   {
     type: "event",
-    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleAdminChanged",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::ApprovalForAll",
     kind: "struct",
     members: [
       {
-        name: "role",
-        type: "core::felt252",
-        kind: "data"
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
       },
       {
-        name: "previous_admin_role",
-        type: "core::felt252",
-        kind: "data"
+        name: "operator",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
       },
       {
-        name: "new_admin_role",
-        type: "core::felt252",
+        name: "approved",
+        type: "core::bool",
         kind: "data"
       }
     ]
   },
   {
     type: "event",
-    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::Event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
     kind: "enum",
     variants: [
       {
-        name: "RoleGranted",
-        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGranted",
-        kind: "nested"
-      },
-      {
-        name: "RoleGrantedWithDelay",
-        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGrantedWithDelay",
+        name: "Transfer",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
         kind: "nested"
       },
       {
-        name: "RoleRevoked",
-        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleRevoked",
+        name: "Approval",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
         kind: "nested"
       },
       {
-        name: "RoleAdminChanged",
-        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleAdminChanged",
+        name: "ApprovalForAll",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::ApprovalForAll",
         kind: "nested"
       }
     ]
   },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::extensions::erc721_enumerable::erc721_enumerable::ERC721EnumerableComponent::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "openzeppelin_introspection::src5::SRC5Component::Event",
+    kind: "enum",
+    variants: []
+  },
   {
     type: "event",
     name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
@@ -39843,390 +39781,1352 @@ var vault_manager_abi_default = [
   },
   {
     type: "event",
-    name: "openzeppelin_security::pausable::PausableComponent::Paused",
-    kind: "struct",
-    members: [
-      {
-        name: "account",
-        type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
-      }
-    ]
-  },
-  {
-    type: "event",
-    name: "openzeppelin_security::pausable::PausableComponent::Unpaused",
-    kind: "struct",
-    members: [
-      {
-        name: "account",
-        type: "core::starknet::contract_address::ContractAddress",
-        kind: "data"
-      }
-    ]
-  },
-  {
-    type: "event",
-    name: "openzeppelin_security::pausable::PausableComponent::Event",
+    name: "vault::redeem_request::redeem_request::RedeemRequest::Event",
     kind: "enum",
     variants: [
       {
-        name: "Paused",
-        type: "openzeppelin_security::pausable::PausableComponent::Paused",
-        kind: "nested"
+        name: "ERC721Event",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
+        kind: "flat"
       },
       {
-        name: "Unpaused",
-        type: "openzeppelin_security::pausable::PausableComponent::Unpaused",
-        kind: "nested"
-      }
-    ]
-  },
-  {
-    type: "event",
-    name: "vault_allocator::manager::manager::Manager::Event",
-    kind: "enum",
-    variants: [
+        name: "ERC721EnumerableEvent",
+        type: "openzeppelin_token::erc721::extensions::erc721_enumerable::erc721_enumerable::ERC721EnumerableComponent::Event",
+        kind: "flat"
+      },
       {
         name: "SRC5Event",
         type: "openzeppelin_introspection::src5::SRC5Component::Event",
-        kind: "nested"
-      },
-      {
-        name: "AccessControlEvent",
-        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::Event",
-        kind: "nested"
+        kind: "flat"
       },
       {
         name: "UpgradeableEvent",
         type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
-        kind: "nested"
-      },
-      {
-        name: "PausableEvent",
-        type: "openzeppelin_security::pausable::PausableComponent::Event",
-        kind: "nested"
+        kind: "flat"
       }
     ]
   }
 ];
 
-// src/strategies/types.ts
-var LSTPriceType = /* @__PURE__ */ ((LSTPriceType2) => {
-  LSTPriceType2["ENDUR_PRICE"] = "ENDUR_PRICE";
-  LSTPriceType2["AVNU_PRICE"] = "AVNU_PRICE";
-  return LSTPriceType2;
-})(LSTPriceType || {});
-
-// 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;
-})(AUMTypes || {});
-var PositionTypeAvnuExtended = /* @__PURE__ */ ((PositionTypeAvnuExtended2) => {
-  PositionTypeAvnuExtended2["OPEN"] = "open";
-  PositionTypeAvnuExtended2["CLOSE"] = "close";
-  return PositionTypeAvnuExtended2;
-})(PositionTypeAvnuExtended || {});
-var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
-  constructor(config, pricer, metadata) {
-    super(config);
-    this.pricer = pricer;
-    assert(
-      metadata.depositTokens.length === 1,
-      "VesuRebalance only supports 1 deposit token"
-    );
-    this.metadata = metadata;
-    this.address = metadata.address;
-    this.contract = new Contract15({
-      abi: universal_vault_abi_default,
-      address: this.address.address,
-      providerOrAccount: this.config.provider
-    });
-    this.managerContract = new Contract15({
-      abi: vault_manager_abi_default,
-      address: this.metadata.additionalInfo.manager.address,
-      providerOrAccount: this.config.provider
-    });
+// src/strategies/universal-adapters/svk-troves-adapter.ts
+var DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
+function parseTrovesApyField(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
   }
-  getMerkleTree() {
-    if (this.merkleTree) return this.merkleTree;
-    const leaves = this.metadata.additionalInfo.leafAdapters.map((adapter, index) => {
-      return adapter();
-    });
-    const standardTree = StandardMerkleTree.of(leaves.flatMap((l) => l.leaves));
-    this.merkleTree = standardTree;
-    return standardTree;
+  if (typeof raw === "string") {
+    const n = Number.parseFloat(raw);
+    if (Number.isFinite(n)) {
+      return n;
+    }
   }
-  getMerkleRoot() {
-    return this.getMerkleTree().root;
+  return 0;
+}
+var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
+  constructor(config) {
+    super(config, _SvkTrovesAdapter.name, Protocols.TROVES);
+    this.config = config;
   }
-  getProofs(id) {
-    const tree = this.getMerkleTree();
-    let proofs = [];
-    for (const [i, v] of tree.entries()) {
-      if (v.readableId == id) {
-        proofs = tree.getProof(i);
-      }
-    }
-    if (proofs.length === 0) {
-      throw new Error(`Proof not found for ID: ${id}`);
+  /** Owner used for share balance + `due_assets_from_owner`. */
+  _positionOwner() {
+    return this.config.positionOwner ?? this.config.vaultAllocator;
+  }
+  /**
+   * Proof readable IDs must stay ≤ 31 chars (Cairo short string). We derive a short ASCII suffix from
+   * `strategyVault` address so multiple SVK adapters in one tree stay distinct.
+   */
+  _proofSuffix() {
+    return this.config.strategyVault.address.replace(/^0x/, "").slice(-6);
+  }
+  _depositApproveProofReadableId() {
+    return `appr_dep_svk_${this._proofSuffix()}`;
+  }
+  _depositCallProofReadableId() {
+    return `dep_svk_${this._proofSuffix()}`;
+  }
+  _withdrawCallProofReadableId() {
+    return `wtdrw_svk_${this._proofSuffix()}`;
+  }
+  async getAPY(supportedPosition) {
+    const CACHE_KEY = `svk_apy_${this.config.trovesStrategyId}`;
+    const cached = this.getCache(CACHE_KEY);
+    if (cached) {
+      return cached;
     }
-    const leafAdapter = this.metadata.additionalInfo.leafAdapters.find((adapter) => adapter().leaves[0]?.readableId === id);
-    if (!leafAdapter) {
-      throw new Error(`Leaf adapter not found for ID: ${id}`);
+    const url = this.config.trovesStrategiesApiUrl ?? DEFAULT_TROVES_STRATEGIES_API;
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        logger.warn(`${_SvkTrovesAdapter.name}::getAPY: HTTP ${res.status} from ${url}`);
+        const fallback = { apy: 0, type: "base" /* BASE */ };
+        this.setCache(CACHE_KEY, fallback, 3e5);
+        return fallback;
+      }
+      const body = await res.json();
+      const row = body.strategies?.find((s) => s.id === this.config.trovesStrategyId);
+      if (!row) {
+        logger.warn(
+          `${_SvkTrovesAdapter.name}::getAPY: strategy id not found: ${this.config.trovesStrategyId}`
+        );
+        const fallback = { apy: 0, type: "base" /* BASE */ };
+        this.setCache(CACHE_KEY, fallback, 3e5);
+        return fallback;
+      }
+      const apy = parseTrovesApyField(row.apy);
+      const result = { apy, type: "base" /* BASE */ };
+      this.setCache(CACHE_KEY, result, 3e5);
+      return result;
+    } catch (error) {
+      logger.error(`${_SvkTrovesAdapter.name}::getAPY:`, error);
+      throw error;
     }
-    const leafInfo = leafAdapter();
-    return {
-      proofs,
-      callConstructor: leafInfo.callConstructor.bind(leafInfo)
-    };
   }
-  getAdapter(id) {
-    const adapter = this.metadata.additionalInfo.adapters.find((adapter2) => adapter2.id === id);
-    if (!adapter) {
-      throw new Error(`Adapter not found for ID: ${id}`);
+  async getPosition(supportedPosition) {
+    const CACHE_KEY = `svk_pos_${this.config.strategyVault.address}_${this._positionOwner().address}`;
+    const cached = this.getCache(CACHE_KEY);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const vault = new Contract14({
+        abi: universal_vault_abi_default,
+        address: this.config.strategyVault.address,
+        providerOrAccount: this.config.networkConfig.provider
+      });
+      const owner = this._positionOwner();
+      const decimals = supportedPosition.asset.decimals;
+      const shares = await vault.balance_of(owner.address);
+      const shareU256 = uint25619.bnToUint256(shares);
+      const liquidAssetsRaw = await vault.convert_to_assets(shareU256);
+      const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
+      let pending = Web3Number.fromWei("0", decimals);
+      try {
+        const dueRaw = await vault.call("due_assets_from_owner", [owner.address]);
+        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
+      } catch (e) {
+        logger.warn(
+          `${_SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${e.message}`
+        );
+      }
+      const total = liquid.plus(pending);
+      const remarks = `Troves ${this.config.trovesStrategyId} holdings`;
+      const result = {
+        amount: total,
+        remarks
+      };
+      this.setCache(CACHE_KEY, result, 6e4);
+      return result;
+    } catch (error) {
+      logger.error(`${_SvkTrovesAdapter.name}::getPosition:`, error);
+      throw error;
     }
-    return adapter.adapter;
-  }
-  asset() {
-    return this.metadata.depositTokens[0];
   }
-  async depositCall(amountInfo, receiver) {
-    assert(
-      amountInfo.tokenInfo.address.eq(this.asset().address),
-      "Deposit token mismatch"
-    );
-    const assetContract = new Contract15({
+  async getPendingAssetsFromOwner(owner = this._positionOwner(), decimals = this.config.baseToken.decimals) {
+    const vault = new Contract14({
       abi: universal_vault_abi_default,
-      address: this.asset().address.address,
-      providerOrAccount: this.config.provider
+      address: this.config.strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider
     });
-    const call1 = assetContract.populate("approve", [
-      this.address.address,
-      uint25620.bnToUint256(amountInfo.amount.toWei())
-    ]);
-    const call2 = this.contract.populate("deposit", [
-      uint25620.bnToUint256(amountInfo.amount.toWei()),
-      receiver.address
-    ]);
-    return [call1, call2];
+    try {
+      const dueRaw = await vault.call("due_assets_from_owner", [owner.address]);
+      return Web3Number.fromWei(dueRaw.toString(), decimals);
+    } catch (e) {
+      logger.warn(
+        `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwner: due_assets_from_owner failed (treating as 0): ${e.message}`
+      );
+      return Web3Number.fromWei("0", decimals);
+    }
   }
-  async withdrawCall(amountInfo, receiver, owner) {
-    assert(
-      amountInfo.tokenInfo.address.eq(this.asset().address),
-      "Withdraw token mismatch"
-    );
-    const shares = await this.contract.call("convert_to_shares", [uint25620.bnToUint256(amountInfo.amount.toWei())]);
-    const call = this.contract.populate("request_redeem", [
-      uint25620.bnToUint256(shares.toString()),
-      receiver.address,
-      owner.address
-    ]);
-    return [call];
+  /**
+   * Get pending assets from owner by scanning redeem request NFTs.
+   * This method iterates backwards through NFT IDs to find all pending redemptions for a specific owner.
+   *
+   * @param redeemRequestNFT - The redeem request NFT contract address
+   * @param owner - The owner address to check for pending redemptions (defaults to positionOwner)
+   * @param decimals - Token decimals for conversion (defaults to baseToken decimals)
+   * @returns Total pending assets from all NFTs owned by the specified address
+   */
+  async getPendingAssetsFromOwnerNFTMethod(redeemRequestNFT, owner = this._positionOwner(), decimals = this.config.baseToken.decimals) {
+    try {
+      const nftContract = new Contract14({
+        abi: redeem_request_nft_abi_default,
+        address: redeemRequestNFT.address,
+        providerOrAccount: this.config.networkConfig.provider
+      });
+      const idLenRaw = await nftContract.id_len();
+      const latestId = BigInt(idLenRaw.toString());
+      if (latestId === 0n) {
+        logger.info(
+          `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: No NFTs minted yet`
+        );
+        return Web3Number.fromWei("0", decimals);
+      }
+      const matchingIds = [];
+      let currentId = latestId - 1n;
+      while (currentId >= 0n) {
+        try {
+          const idU256 = uint25619.bnToUint256(currentId);
+          const ownerRaw = await nftContract.owner_of(idU256);
+          const nftOwnerAddr = ContractAddr.from(ownerRaw.toString());
+          if (nftOwnerAddr.eq(owner)) {
+            matchingIds.push(currentId);
+            logger.debug(
+              `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found matching NFT ID ${currentId} for owner ${owner.address}`
+            );
+          }
+          currentId--;
+        } catch (e) {
+          logger.info(
+            `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Reached last pending NFT at id ${currentId}`
+          );
+          break;
+        }
+      }
+      if (matchingIds.length === 0) {
+        logger.info(
+          `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: No matching NFTs found for owner ${owner.address}`
+        );
+        return Web3Number.fromWei("0", decimals);
+      }
+      let totalNominal = 0n;
+      for (const nftId of matchingIds) {
+        try {
+          const idU256 = uint25619.bnToUint256(nftId);
+          const infoRaw = await nftContract.id_to_info(idU256);
+          const nominal = BigInt(infoRaw.nominal.toString());
+          totalNominal += nominal;
+          logger.debug(
+            `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: NFT ID ${nftId} has nominal ${nominal}`
+          );
+        } catch (e) {
+          logger.warn(
+            `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Failed to get info for NFT ID ${nftId}: ${e.message}`
+          );
+        }
+      }
+      logger.info(
+        `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found ${matchingIds.length} NFTs with total nominal ${totalNominal}`
+      );
+      return Web3Number.fromWei(totalNominal.toString(), decimals);
+    } catch (error) {
+      logger.error(
+        `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: ${error.message}`
+      );
+      return Web3Number.fromWei("0", decimals);
+    }
   }
-  async getUserTVL(user, blockIdentifier = "latest") {
-    const shares = await this.contract.call("balanceOf", [user.address], { blockIdentifier });
-    const assets = await this.contract.call(
-      "convert_to_assets",
-      [uint25620.bnToUint256(shares)],
-      { blockIdentifier }
-    );
-    const amount = Web3Number.fromWei(
-      assets.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    const blockNumber = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? Number(blockIdentifier) : void 0;
-    let price = await this.pricer.getPrice(
-      this.metadata.depositTokens[0].symbol,
-      blockNumber
-    );
-    const usdValue = Number(amount.toFixed(6)) * price.price;
+  async maxDeposit(amount) {
+    const baseToken = this.config.baseToken;
+    if (!amount) {
+      return {
+        tokenInfo: baseToken,
+        amount: new Web3Number("999999999999999999999999999", baseToken.decimals),
+        usdValue: 1e27,
+        remarks: "Max deposit (unbounded placeholder)",
+        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+        protocol: this.protocol
+      };
+    }
+    const usdValue = await this.getUSDValue(baseToken, amount);
     return {
-      tokenInfo: this.asset(),
+      tokenInfo: baseToken,
       amount,
-      usdValue
+      usdValue,
+      remarks: "Deposit amount",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
     };
   }
-  async getVesuAPYs() {
-    const vesuAdapters = this.getVesuAdapters();
-    const allVesuPools = await VesuAdapter.getVesuPools();
-    const pools = vesuAdapters.map((vesuAdapter) => {
-      return allVesuPools.pools.find((p) => vesuAdapter.config.poolId.eqString(num12.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 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.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
-      const debtAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase())?.stats;
-      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
-      const lstAPY = await this.getLSTAPR(vesuAdapter.config.collateral.address);
-      logger.verbose(`${this.metadata.name}::netAPY: ${vesuAdapter.config.collateral.symbol} LST APR from Endur: ${lstAPY}`);
-      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");
+  async maxWithdraw() {
+    const baseToken = this.config.baseToken;
+    const current = await this.getPosition({ asset: baseToken, isDebt: false });
+    const pos = current ?? { amount: new Web3Number("0", baseToken.decimals), remarks: "" };
+    const usdValue = await this.getUSDValue(baseToken, pos.amount);
     return {
-      baseAPYs,
-      rewardAPYs,
-      positions
+      tokenInfo: baseToken,
+      amount: pos.amount,
+      usdValue,
+      remarks: "Max withdraw (liquid + pending redemption, underlying units)",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
     };
   }
-  /**
-   * Calculates the weighted average APY across all pools based on USD value.
-   * @returns {Promise<number>} The weighted average APY across all pools
-   */
-  async netAPY() {
-    if (this.metadata.isPreview) {
-      return { net: 0, splits: [{
-        apy: 0,
-        id: "base"
-      }, {
-        apy: 0,
-        id: "defispring"
-      }] };
-    }
-    const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
-    const unusedBalanceAPY = await this.getUnusedBalanceAPY();
-    baseAPYs.push(...[unusedBalanceAPY.apy]);
-    rewardAPYs.push(0);
-    const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
-    weights.push(unusedBalanceAPY.weight);
-    const prevAUM = await this.getPrevAUM();
-    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
-    const prevAUMUSD = prevAUM.multipliedBy(price.price);
-    return this.returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD);
-  }
-  async returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD) {
-    if (weights.every((p) => p == 0)) {
-      return { net: 0, splits: [{
-        apy: 0,
-        id: "base"
-      }, {
-        apy: 0,
-        id: "defispring"
-      }] };
-    }
-    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: [{
-      apy: baseAPY,
-      id: "base"
-    }, {
-      apy: rewardAPY,
-      id: "defispring"
-    }] };
+  _getDepositLeaf() {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const receiver = this.config.vaultAllocator;
+    return [
+      {
+        target: baseToken.address,
+        method: "approve",
+        packedArguments: [strategyVault.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositApproveProofReadableId()
+      },
+      {
+        target: strategyVault,
+        method: "deposit",
+        packedArguments: [receiver.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositCallProofReadableId()
+      }
+    ];
   }
-  async getUnusedBalanceAPY() {
-    return {
-      apy: 0,
-      weight: 0
-    };
+  _getWithdrawLeaf() {
+    const strategyVault = this.config.strategyVault;
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+    return [
+      {
+        target: strategyVault,
+        method: "request_redeem",
+        packedArguments: [recv.toBigInt(), owner.toBigInt()],
+        sanitizer: SVK_SIMPLE_SANITIZER,
+        id: this._withdrawCallProofReadableId()
+      }
+    ];
   }
-  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);
-    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
-    return weightedSum / currentAUM.toNumber();
+  getDepositAdapter() {
+    const leafConfigs = this._getDepositLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
+    });
+    return { leaves, callConstructor: this.getDepositCall.bind(this) };
   }
-  /**
-   * Calculates user realized APY based on trueSharesBasedAPY method.
-   * Returns the APY as a number.
-   */
-  async getUserRealizedAPY(blockIdentifier = "latest", sinceBlocks = 6e5) {
-    logger.verbose(
-      `${this.getTag()}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
-    );
-    let blockNow = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? Number(blockIdentifier) : (await this.config.provider.getBlockLatestAccepted()).block_number;
-    const blockNowTime = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? (await this.config.provider.getBlockWithTxs(blockIdentifier)).timestamp : (/* @__PURE__ */ new Date()).getTime() / 1e3;
-    const blockBefore = Math.max(
-      blockNow - sinceBlocks,
-      this.metadata.launchBlock
-    );
-    const assetsNowRaw = await this.contract.call("total_assets", [], {
-      blockIdentifier
+  getWithdrawAdapter() {
+    const leafConfigs = this._getWithdrawLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
     });
-    const amountNow = Web3Number.fromWei(
-      assetsNowRaw.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    const supplyNowRaw = await this.contract.call("total_supply", [], {
-      blockIdentifier
+    return { leaves, callConstructor: this.getWithdrawCall.bind(this) };
+  }
+  async getDepositCall(params) {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint25619.bnToUint256(amount.toWei());
+    const receiver = this.config.vaultAllocator;
+    return [
+      {
+        proofReadableId: this._depositApproveProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: baseToken.address,
+          selector: hash11.getSelectorFromName("approve"),
+          calldata: [
+            strategyVault.toBigInt(),
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString())
+          ]
+        }
+      },
+      {
+        proofReadableId: this._depositCallProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash11.getSelectorFromName("deposit"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+            receiver.toBigInt()
+          ]
+        }
+      }
+    ];
+  }
+  async getWithdrawCall(params) {
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint25619.bnToUint256(amount.toWei());
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+    const vault = new Contract14({
+      abi: universal_vault_abi_default,
+      address: strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider
     });
-    const supplyNow = Web3Number.fromWei(supplyNowRaw.toString(), 18);
-    const assetsBeforeRaw = await this.contract.call(
-      "total_assets",
-      [],
-      { blockIdentifier: blockBefore }
-    );
-    const amountBefore = Web3Number.fromWei(
-      assetsBeforeRaw.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    const supplyBeforeRaw = await this.contract.call(
-      "total_supply",
-      [],
-      { blockIdentifier: blockBefore }
-    );
-    const supplyBefore = Web3Number.fromWei(supplyBeforeRaw.toString(), 18);
-    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
-      blockBefore
-    );
-    const assetsPerShareNow = amountNow.multipliedBy(1e18).dividedBy(supplyNow.toString());
-    const assetsPerShareBf = amountBefore.multipliedBy(1e18).dividedBy(supplyBefore.toString());
-    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`);
-    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Time diff in seconds: ${timeDiffSeconds}`);
-    const apyForGivenBlocks = Number(
-      assetsPerShareNow.minus(assetsPerShareBf).multipliedBy(1e4).dividedBy(assetsPerShareBf)
-    ) / 1e4;
-    return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
+    const sharesRaw = await vault.convert_to_shares(uint256Amount);
+    const sharesU256 = uint25619.bnToUint256(sharesRaw.toString());
+    return [
+      {
+        proofReadableId: this._withdrawCallProofReadableId(),
+        sanitizer: SVK_SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash11.getSelectorFromName("request_redeem"),
+          calldata: [
+            toBigInt(sharesU256.low.toString()),
+            toBigInt(sharesU256.high.toString()),
+            recv.toBigInt(),
+            owner.toBigInt()
+          ]
+        }
+      }
+    ];
   }
-  /**
-     * Calculates the total TVL of the strategy.
-     * @returns Object containing the total amount in token units and USD value
-  */
-  async getTVL() {
-    const assets = await this.contract.total_assets();
-    const amount = Web3Number.fromWei(
-      assets.toString(),
-      this.metadata.depositTokens[0].decimals
-    );
-    let price = await this.pricer.getPrice(
-      this.metadata.depositTokens[0].symbol
-    );
-    const usdValue = Number(amount.toFixed(6)) * price.price;
-    return {
-      tokenInfo: this.asset(),
-      amount,
-      usdValue
-    };
+  getHealthFactor() {
+    return Promise.resolve(10);
   }
-  async getUnusedBalance() {
-    const balance = await new ERC20(this.config).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
-    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
-    const usdValue = Number(balance.toFixed(6)) * price.price;
-    return {
-      tokenInfo: this.asset(),
+};
+
+// src/strategies/universal-strategy.tsx
+import { CallData, Contract as Contract15, num as num12, uint256 as uint25620 } from "starknet";
+
+// src/data/vault-manager.abi.json
+var vault_manager_abi_default = [
+  {
+    type: "impl",
+    name: "UpgradeableImpl",
+    interface_name: "openzeppelin_upgrades::interface::IUpgradeable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_upgrades::interface::IUpgradeable",
+    items: [
+      {
+        type: "function",
+        name: "upgrade",
+        inputs: [
+          {
+            name: "new_class_hash",
+            type: "core::starknet::class_hash::ClassHash"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "ManagerFlashloanReceiverImpl",
+    interface_name: "vault_allocator::integration_interfaces::vesu::IFlashloanReceiver"
+  },
+  {
+    type: "struct",
+    name: "core::integer::u256",
+    members: [
+      {
+        name: "low",
+        type: "core::integer::u128"
+      },
+      {
+        name: "high",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "vault_allocator::integration_interfaces::vesu::IFlashloanReceiver",
+    items: [
+      {
+        type: "function",
+        name: "on_flash_loan",
+        inputs: [
+          {
+            name: "sender",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "asset",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "ManagerImpl",
+    interface_name: "vault_allocator::manager::interface::IManager"
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::array::Span::<core::felt252>>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::array::Span::<core::felt252>>"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::starknet::contract_address::ContractAddress>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::starknet::contract_address::ContractAddress>"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "vault_allocator::manager::interface::IManager",
+    items: [
+      {
+        type: "function",
+        name: "vesu_singleton",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "vault_allocator",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "set_manage_root",
+        inputs: [
+          {
+            name: "target",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "root",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "manage_root",
+        inputs: [
+          {
+            name: "target",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::felt252"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "pause",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "unpause",
+        inputs: [],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "manage_vault_with_merkle_verification",
+        inputs: [
+          {
+            name: "proofs",
+            type: "core::array::Span::<core::array::Span::<core::felt252>>"
+          },
+          {
+            name: "decoder_and_sanitizers",
+            type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
+          },
+          {
+            name: "targets",
+            type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
+          },
+          {
+            name: "selectors",
+            type: "core::array::Span::<core::felt252>"
+          },
+          {
+            name: "calldatas",
+            type: "core::array::Span::<core::array::Span::<core::felt252>>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "flash_loan",
+        inputs: [
+          {
+            name: "recipient",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "asset",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "amount",
+            type: "core::integer::u256"
+          },
+          {
+            name: "is_legacy",
+            type: "core::bool"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "get_leaf_hash",
+        inputs: [
+          {
+            name: "decoder_and_sanitizer",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "target",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "selector",
+            type: "core::felt252"
+          },
+          {
+            name: "packed_argument_addresses",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::felt252"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "AccessControlImpl",
+    interface_name: "openzeppelin_access::accesscontrol::interface::IAccessControl"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_access::accesscontrol::interface::IAccessControl",
+    items: [
+      {
+        type: "function",
+        name: "has_role",
+        inputs: [
+          {
+            name: "role",
+            type: "core::felt252"
+          },
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_role_admin",
+        inputs: [
+          {
+            name: "role",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::felt252"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "grant_role",
+        inputs: [
+          {
+            name: "role",
+            type: "core::felt252"
+          },
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "revoke_role",
+        inputs: [
+          {
+            name: "role",
+            type: "core::felt252"
+          },
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "renounce_role",
+        inputs: [
+          {
+            name: "role",
+            type: "core::felt252"
+          },
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "PausableImpl",
+    interface_name: "openzeppelin_security::interface::IPausable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_security::interface::IPausable",
+    items: [
+      {
+        type: "function",
+        name: "is_paused",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "vault_allocator",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "vesu_singleton",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_introspection::src5::SRC5Component::Event",
+    kind: "enum",
+    variants: []
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGranted",
+    kind: "struct",
+    members: [
+      {
+        name: "role",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      },
+      {
+        name: "sender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGrantedWithDelay",
+    kind: "struct",
+    members: [
+      {
+        name: "role",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      },
+      {
+        name: "sender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      },
+      {
+        name: "delay",
+        type: "core::integer::u64",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleRevoked",
+    kind: "struct",
+    members: [
+      {
+        name: "role",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      },
+      {
+        name: "sender",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleAdminChanged",
+    kind: "struct",
+    members: [
+      {
+        name: "role",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "previous_admin_role",
+        type: "core::felt252",
+        kind: "data"
+      },
+      {
+        name: "new_admin_role",
+        type: "core::felt252",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "RoleGranted",
+        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGranted",
+        kind: "nested"
+      },
+      {
+        name: "RoleGrantedWithDelay",
+        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleGrantedWithDelay",
+        kind: "nested"
+      },
+      {
+        name: "RoleRevoked",
+        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleRevoked",
+        kind: "nested"
+      },
+      {
+        name: "RoleAdminChanged",
+        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::RoleAdminChanged",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+    kind: "struct",
+    members: [
+      {
+        name: "class_hash",
+        type: "core::starknet::class_hash::ClassHash",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Upgraded",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Upgraded",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Paused",
+    kind: "struct",
+    members: [
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Unpaused",
+    kind: "struct",
+    members: [
+      {
+        name: "account",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_security::pausable::PausableComponent::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Paused",
+        type: "openzeppelin_security::pausable::PausableComponent::Paused",
+        kind: "nested"
+      },
+      {
+        name: "Unpaused",
+        type: "openzeppelin_security::pausable::PausableComponent::Unpaused",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "vault_allocator::manager::manager::Manager::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "SRC5Event",
+        type: "openzeppelin_introspection::src5::SRC5Component::Event",
+        kind: "nested"
+      },
+      {
+        name: "AccessControlEvent",
+        type: "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::Event",
+        kind: "nested"
+      },
+      {
+        name: "UpgradeableEvent",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+        kind: "nested"
+      },
+      {
+        name: "PausableEvent",
+        type: "openzeppelin_security::pausable::PausableComponent::Event",
+        kind: "nested"
+      }
+    ]
+  }
+];
+
+// src/strategies/types.ts
+var LSTPriceType = /* @__PURE__ */ ((LSTPriceType2) => {
+  LSTPriceType2["ENDUR_PRICE"] = "ENDUR_PRICE";
+  LSTPriceType2["AVNU_PRICE"] = "AVNU_PRICE";
+  return LSTPriceType2;
+})(LSTPriceType || {});
+
+// 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;
+})(AUMTypes || {});
+var PositionTypeAvnuExtended = /* @__PURE__ */ ((PositionTypeAvnuExtended2) => {
+  PositionTypeAvnuExtended2["OPEN"] = "open";
+  PositionTypeAvnuExtended2["CLOSE"] = "close";
+  return PositionTypeAvnuExtended2;
+})(PositionTypeAvnuExtended || {});
+var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
+  constructor(config, pricer, metadata) {
+    super(config);
+    this.pricer = pricer;
+    assert(
+      metadata.depositTokens.length === 1,
+      "VesuRebalance only supports 1 deposit token"
+    );
+    this.metadata = metadata;
+    this.address = metadata.address;
+    this.contract = new Contract15({
+      abi: universal_vault_abi_default,
+      address: this.address.address,
+      providerOrAccount: this.config.provider
+    });
+    this.managerContract = new Contract15({
+      abi: vault_manager_abi_default,
+      address: this.metadata.additionalInfo.manager.address,
+      providerOrAccount: this.config.provider
+    });
+  }
+  getMerkleTree() {
+    if (this.merkleTree) return this.merkleTree;
+    const leaves = this.metadata.additionalInfo.leafAdapters.map((adapter, index) => {
+      return adapter();
+    });
+    const standardTree = StandardMerkleTree.of(leaves.flatMap((l) => l.leaves));
+    this.merkleTree = standardTree;
+    return standardTree;
+  }
+  getMerkleRoot() {
+    return this.getMerkleTree().root;
+  }
+  getProofs(id) {
+    const tree = this.getMerkleTree();
+    let proofs = [];
+    for (const [i, v] of tree.entries()) {
+      if (v.readableId == id) {
+        proofs = tree.getProof(i);
+      }
+    }
+    if (proofs.length === 0) {
+      throw new Error(`Proof not found for ID: ${id}`);
+    }
+    const leafAdapter = this.metadata.additionalInfo.leafAdapters.find((adapter) => adapter().leaves[0]?.readableId === id);
+    if (!leafAdapter) {
+      throw new Error(`Leaf adapter not found for ID: ${id}`);
+    }
+    const leafInfo = leafAdapter();
+    return {
+      proofs,
+      callConstructor: leafInfo.callConstructor.bind(leafInfo)
+    };
+  }
+  getAdapter(id) {
+    const adapter = this.metadata.additionalInfo.adapters.find((adapter2) => adapter2.id === id);
+    if (!adapter) {
+      throw new Error(`Adapter not found for ID: ${id}`);
+    }
+    return adapter.adapter;
+  }
+  asset() {
+    return this.metadata.depositTokens[0];
+  }
+  async depositCall(amountInfo, receiver) {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Deposit token mismatch"
+    );
+    const assetContract = new Contract15({
+      abi: universal_vault_abi_default,
+      address: this.asset().address.address,
+      providerOrAccount: this.config.provider
+    });
+    const call1 = assetContract.populate("approve", [
+      this.address.address,
+      uint25620.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      uint25620.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    return [call1, call2];
+  }
+  async withdrawCall(amountInfo, receiver, owner) {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = await this.contract.call("convert_to_shares", [uint25620.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint25620.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
+  async getUserTVL(user, blockIdentifier = "latest") {
+    const shares = await this.contract.call("balanceOf", [user.address], { blockIdentifier });
+    const assets = await this.contract.call(
+      "convert_to_assets",
+      [uint25620.bnToUint256(shares)],
+      { blockIdentifier }
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const blockNumber = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? Number(blockIdentifier) : void 0;
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+      blockNumber
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+  async getVesuAPYs() {
+    const vesuAdapters = this.getVesuAdapters();
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const pools = vesuAdapters.map((vesuAdapter) => {
+      return allVesuPools.pools.find((p) => vesuAdapter.config.poolId.eqString(num12.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 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.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
+      const debtAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase())?.stats;
+      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+      const lstAPY = await this.getLSTAPR(vesuAdapter.config.collateral.address);
+      logger.verbose(`${this.metadata.name}::netAPY: ${vesuAdapter.config.collateral.symbol} LST APR from Endur: ${lstAPY}`);
+      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");
+    return {
+      baseAPYs,
+      rewardAPYs,
+      positions
+    };
+  }
+  /**
+   * Calculates the weighted average APY across all pools based on USD value.
+   * @returns {Promise<number>} The weighted average APY across all pools
+   */
+  async netAPY() {
+    if (this.metadata.isPreview) {
+      return { net: 0, splits: [{
+        apy: 0,
+        id: "base"
+      }, {
+        apy: 0,
+        id: "defispring"
+      }] };
+    }
+    const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+    const unusedBalanceAPY = await this.getUnusedBalanceAPY();
+    baseAPYs.push(...[unusedBalanceAPY.apy]);
+    rewardAPYs.push(0);
+    const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+    weights.push(unusedBalanceAPY.weight);
+    const prevAUM = await this.getPrevAUM();
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const prevAUMUSD = prevAUM.multipliedBy(price.price);
+    return this.returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD);
+  }
+  async returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD) {
+    if (weights.every((p) => p == 0)) {
+      return { net: 0, splits: [{
+        apy: 0,
+        id: "base"
+      }, {
+        apy: 0,
+        id: "defispring"
+      }] };
+    }
+    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: [{
+      apy: baseAPY,
+      id: "base"
+    }, {
+      apy: rewardAPY,
+      id: "defispring"
+    }] };
+  }
+  async getUnusedBalanceAPY() {
+    return {
+      apy: 0,
+      weight: 0
+    };
+  }
+  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);
+    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
+    return weightedSum / currentAUM.toNumber();
+  }
+  /**
+   * Calculates user realized APY based on trueSharesBasedAPY method.
+   * Returns the APY as a number.
+   */
+  async getUserRealizedAPY(blockIdentifier = "latest", sinceBlocks = 6e5) {
+    logger.verbose(
+      `${this.getTag()}: getUserRealizedAPY => starting with blockIdentifier=${blockIdentifier}, sinceBlocks=${sinceBlocks}`
+    );
+    let blockNow = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? Number(blockIdentifier) : (await this.config.provider.getBlockLatestAccepted()).block_number;
+    const blockNowTime = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? (await this.config.provider.getBlockWithTxs(blockIdentifier)).timestamp : (/* @__PURE__ */ new Date()).getTime() / 1e3;
+    const blockBefore = Math.max(
+      blockNow - sinceBlocks,
+      this.metadata.launchBlock
+    );
+    const assetsNowRaw = await this.contract.call("total_assets", [], {
+      blockIdentifier
+    });
+    const amountNow = Web3Number.fromWei(
+      assetsNowRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const supplyNowRaw = await this.contract.call("total_supply", [], {
+      blockIdentifier
+    });
+    const supplyNow = Web3Number.fromWei(supplyNowRaw.toString(), 18);
+    const assetsBeforeRaw = await this.contract.call(
+      "total_assets",
+      [],
+      { blockIdentifier: blockBefore }
+    );
+    const amountBefore = Web3Number.fromWei(
+      assetsBeforeRaw.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const supplyBeforeRaw = await this.contract.call(
+      "total_supply",
+      [],
+      { blockIdentifier: blockBefore }
+    );
+    const supplyBefore = Web3Number.fromWei(supplyBeforeRaw.toString(), 18);
+    const blockBeforeInfo = await this.config.provider.getBlockWithTxs(
+      blockBefore
+    );
+    const assetsPerShareNow = amountNow.multipliedBy(1e18).dividedBy(supplyNow.toString());
+    const assetsPerShareBf = amountBefore.multipliedBy(1e18).dividedBy(supplyBefore.toString());
+    const timeDiffSeconds = blockNowTime - blockBeforeInfo.timestamp;
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsNow: ${amountNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsBefore: ${amountBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareNow: ${assetsPerShareNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] assetsPerShareBf: ${assetsPerShareBf.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply before: ${supplyBefore.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Supply now: ${supplyNow.toString()}`);
+    logger.verbose(`${this.getTag()} [getUserRealizedAPY] Time diff in seconds: ${timeDiffSeconds}`);
+    const apyForGivenBlocks = Number(
+      assetsPerShareNow.minus(assetsPerShareBf).multipliedBy(1e4).dividedBy(assetsPerShareBf)
+    ) / 1e4;
+    return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
+  }
+  /**
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
+  */
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+  async getUnusedBalance() {
+    const balance = await new ERC20(this.config).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
       amount: balance,
       usdValue
     };
@@ -41044,9 +41944,9 @@ var SVKStrategy = class extends BaseStrategy {
     * Builds a manage call from an adapter's proof tree.
     * DRY helper for the repeated getProofs → getManageCall pattern.
     */
-  async buildManageCallFromAdapter(adapter, isDeposit, amount) {
+  async buildManageCallFromAdapter(adapter, isDeposit, amount, additionalParams) {
     const proofsInfo = adapter.getProofs(isDeposit, this.getMerkleTree());
-    const manageCalls = await proofsInfo.callConstructor({ amount });
+    const manageCalls = await proofsInfo.callConstructor({ amount, ...additionalParams });
     return this.getManageCall(
       this.getProofGroupsForManageCalls(manageCalls),
       manageCalls
@@ -42066,177 +42966,697 @@ var hyperxLBTC = {
   underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "LBTC"),
   quoteAmountToFetchPrice: new Web3Number("0.001", Global.getDefaultTokens().find((token) => token.symbol === "LBTC").decimals)
 };
-var hypermRe7BTC = {
-  vaultAddress: ContractAddr.from("0x6c89b75d09de82477edb86b2c2918cfc1a5dc0177cfbdea46278386b6499645"),
-  manager: ContractAddr.from("0x7bc2d0535e13352d3ab78ea047616a3162068294297304943d2302122a150a1"),
-  vaultAllocator: ContractAddr.from("0x760f9cebca9d2ee624f4224591da6da8b3ea5fd2410590735709551bd4e7570"),
-  redeemRequestNFT: ContractAddr.from("0x5e045ae0160f7650f8a4dd7c826f25630a89fe62434db4441e7e0075608180f"),
-  aumOracle: ContractAddr.from("0x3958df341b838813c24efb9183c23bddd1c57d44b1b86c0dd57f67887b89fba"),
-  leafAdapters: [],
-  adapters: [],
-  targetHealthFactor: 1.1,
-  minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
-  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "WBTC"),
-  quoteAmountToFetchPrice: new Web3Number("0.001", Global.getDefaultTokens().find((token) => token.symbol === "mRe7BTC").decimals)
+var hypermRe7BTC = {
+  vaultAddress: ContractAddr.from("0x6c89b75d09de82477edb86b2c2918cfc1a5dc0177cfbdea46278386b6499645"),
+  manager: ContractAddr.from("0x7bc2d0535e13352d3ab78ea047616a3162068294297304943d2302122a150a1"),
+  vaultAllocator: ContractAddr.from("0x760f9cebca9d2ee624f4224591da6da8b3ea5fd2410590735709551bd4e7570"),
+  redeemRequestNFT: ContractAddr.from("0x5e045ae0160f7650f8a4dd7c826f25630a89fe62434db4441e7e0075608180f"),
+  aumOracle: ContractAddr.from("0x3958df341b838813c24efb9183c23bddd1c57d44b1b86c0dd57f67887b89fba"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "WBTC"),
+  quoteAmountToFetchPrice: new Web3Number("0.001", Global.getDefaultTokens().find((token) => token.symbol === "mRe7BTC").decimals)
+};
+var hypermRe7YIELD = {
+  vaultAddress: ContractAddr.from("0x42797ab4eb1f72787442e91a73d63a39e3a141c1106470a946ecc328db6896c"),
+  manager: ContractAddr.from("0x435b45d40fbb406cf69ac84bb471e7b7a4ea2295d0893c05dd2db565295e77f"),
+  vaultAllocator: ContractAddr.from("0x456c4c6afca90512aeb5c735d84405fea6e51ab06d1851ac8cdb0a235e14f15"),
+  redeemRequestNFT: ContractAddr.from("0x4bbb25c2568af07967342833f7db1aece1be1be2330798dab4ee585aa6c2c72"),
+  aumOracle: ContractAddr.from("0x3e1f2825158cafccc9b42a8165d17ceb6b8e966474d9c63587d338746888382"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05,
+  borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "USDC")],
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "USDC"),
+  quoteAmountToFetchPrice: new Web3Number("0.001", Global.getDefaultTokens().find((token) => token.symbol === "mRe7BTC").decimals)
+};
+function getInvestmentSteps(lstSymbol, underlyingSymbol) {
+  return [
+    `Deposit ${lstSymbol} 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`,
+    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
+  ];
+}
+function getMaxTVL(lstSymbol) {
+  const lstMaxTVLs = {
+    xWBTC: 5,
+    xLBTC: 5,
+    xtBTC: 5,
+    xsBTC: 5,
+    xSTRK: 7e6
+  };
+  const maxTVLValue = lstMaxTVLs[lstSymbol] || 0;
+  const token = Global.getDefaultTokens().find(
+    (token2) => token2.symbol === lstSymbol
+  );
+  if (!token) {
+    return Web3Number.fromWei(0, 18);
+  }
+  return Web3Number.fromWei(maxTVLValue, token.decimals);
+}
+function createHyperLSTSettings(lstSymbol, underlyingSymbol) {
+  const depositToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol
+  );
+  return {
+    maxTVL: getMaxTVL(lstSymbol),
+    isPaused: false,
+    liveStatus: "Hot & New \u{1F525}" /* HOT */,
+    isAudited: true,
+    isInstantWithdrawal: false,
+    hideHarvestInfo: true,
+    quoteToken: depositToken,
+    showWithdrawalWarningModal: false,
+    alerts: [
+      {
+        tab: "withdraw",
+        text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 24 hours (In this initial phase of Launch). You can monitor the status in transactions tab.",
+        type: "info"
+      },
+      {
+        tab: "deposit",
+        text: /* @__PURE__ */ jsxs4(Fragment3, { children: [
+          "To acquire the LST, please visit",
+          " ",
+          /* @__PURE__ */ jsx5("a", { href: "https://app.endur.fi", target: "_blank", rel: "noopener noreferrer", children: "endur.fi" })
+        ] }),
+        type: "info"
+      },
+      {
+        tab: "deposit",
+        text: "It may take up to one week for your deposit to appreciate in value. This delay occurs because the LST price is sourced from DEXes and liquidity is usually rebased once a week.",
+        type: "info"
+      }
+    ]
+  };
+}
+var HYPER_LST_SECURITY = {
+  auditStatus: "Audited" /* AUDITED */,
+  sourceCode: {
+    type: "Closed Source" /* CLOSED_SOURCE */,
+    contractLink: "https://github.com/trovesfi/troves-contracts"
+  },
+  accessControl: {
+    type: "Standard Account" /* STANDARD_ACCOUNT */,
+    addresses: [ContractAddr.from("0x0")],
+    timeLock: "2 Days"
+  }
+};
+var HYPER_LST_REDEMPTION_INFO = {
+  instantWithdrawalVault: "No" /* NO */,
+  redemptionsInfo: [
+    {
+      title: "Typical Duration",
+      description: "1-2 hours"
+    }
+  ],
+  alerts: [
+    {
+      type: "info",
+      text: "In cases of low liquidity, high slippages, the redemptions can take longer time. Redemption times are estimates and may vary based on network conditions and liquidity requirements.",
+      tab: "withdraw"
+    }
+  ]
 };
-var hypermRe7YIELD = {
-  vaultAddress: ContractAddr.from("0x42797ab4eb1f72787442e91a73d63a39e3a141c1106470a946ecc328db6896c"),
-  manager: ContractAddr.from("0x435b45d40fbb406cf69ac84bb471e7b7a4ea2295d0893c05dd2db565295e77f"),
-  vaultAllocator: ContractAddr.from("0x456c4c6afca90512aeb5c735d84405fea6e51ab06d1851ac8cdb0a235e14f15"),
-  redeemRequestNFT: ContractAddr.from("0x4bbb25c2568af07967342833f7db1aece1be1be2330798dab4ee585aa6c2c72"),
-  aumOracle: ContractAddr.from("0x3e1f2825158cafccc9b42a8165d17ceb6b8e966474d9c63587d338746888382"),
-  leafAdapters: [],
-  adapters: [],
-  targetHealthFactor: 1.1,
-  minHealthFactor: 1.05,
-  borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "USDC")],
-  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "USDC"),
-  quoteAmountToFetchPrice: new Web3Number("0.001", Global.getDefaultTokens().find((token) => token.symbol === "mRe7BTC").decimals)
+function getStrategySettings(lstSymbol, underlyingSymbol, settings, isPreview = false, isLST) {
+  return {
+    id: `hyper_${lstSymbol.toLowerCase()}`,
+    name: `Hyper ${lstSymbol}`,
+    description: getDescription2(lstSymbol, underlyingSymbol),
+    address: settings.vaultAddress,
+    launchBlock: 0,
+    type: "Other",
+    vaultType: {
+      type: "Looping" /* LOOPING */,
+      description: `Creates leveraged looping position on ${lstSymbol} by borrowing ${underlyingSymbol} to increase yield`
+    },
+    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === lstSymbol)],
+    additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, settings, lstSymbol === "xSTRK" ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
+    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)
+    },
+    auditUrl: AUDIT_URL4,
+    protocols: [Protocols.ENDUR, Protocols.VESU],
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
+    },
+    settings: createHyperLSTSettings(lstSymbol, underlyingSymbol),
+    contractDetails: getContractDetails(settings),
+    faqs: getFAQs2(lstSymbol, underlyingSymbol, isLST),
+    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    isPreview,
+    apyMethodology: "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
+    realizedAPYMethodology: "The realizedAPY is based on past 14 days performance by the vault",
+    tags: lstSymbol.includes("BTC") ? ["BTC" /* BTC */, "Maxx" /* LEVERED */] : ["Maxx" /* LEVERED */],
+    security: HYPER_LST_SECURITY,
+    redemptionInfo: HYPER_LST_REDEMPTION_INFO,
+    usualTimeToEarnings: "2 weeks",
+    usualTimeToEarningsDescription: "Strategy returns depend on LST price on DEXes. Even though the true price of LST on Endur increases continuously, the DEX price may lag sometimes, and historically is seen to rebase at least once every 2 hours. This is when you realise your earnings.",
+    points: lstSymbol === "xSTRK" ? [{
+      multiplier: 4,
+      logo: "https://endur.fi/favicon.ico",
+      toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi."
+    }] : void 0
+  };
+}
+var HyperLSTStrategies = [
+  getStrategySettings("xSTRK", "STRK", hyperxSTRK, false, true),
+  getStrategySettings("xWBTC", "WBTC", hyperxWBTC, false, false),
+  getStrategySettings("xtBTC", "tBTC", hyperxtBTC, false, false),
+  getStrategySettings("xsBTC", "solvBTC", hyperxsBTC, false, false),
+  getStrategySettings("xLBTC", "LBTC", hyperxLBTC, false, false),
+  getStrategySettings("mRe7BTC", "mRe7BTC", hypermRe7BTC, false, false),
+  getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
+];
+
+// src/strategies/usdc-boosted-strategy.tsx
+import { uint256 as uint25623 } from "starknet";
+var USDCBoostedStrategy = class _USDCBoostedStrategy extends SVKStrategy {
+  constructor(config, pricer, metadata) {
+    super(config, pricer, metadata);
+    this.metadata.additionalInfo.adapters.forEach((adapter) => {
+      adapter.adapter.config.networkConfig = this.config;
+      adapter.adapter.config.pricer = this.pricer;
+      if (adapter.adapter._vesuAdapter) {
+        adapter.adapter._vesuAdapter.networkConfig = this.config;
+        adapter.adapter._vesuAdapter.pricer = this.pricer;
+      }
+    });
+  }
+  getTag() {
+    return `${_USDCBoostedStrategy.name}:${this.metadata.name}`;
+  }
+  getAdapterById(id) {
+    const entry = this.metadata.additionalInfo.adapters.find(
+      (a) => a.id === id
+    );
+    if (!entry) {
+      throw new Error(
+        `${this.getTag()}::getAdapterById: adapter not found for id "${id}"`
+      );
+    }
+    return entry.adapter;
+  }
+  async getVesuModifyPositionCall(params) {
+    logger.verbose(
+      `${this.getTag()}::getVesuModifyPositionCall isDeposit=${params.isDeposit}, amount=${params.leg1DepositAmount}, debtAmount=${params.debtAmount?.toNumber()}`
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById("vesu_usdc_strk"),
+      params.isDeposit,
+      params.leg1DepositAmount,
+      params.debtAmount ? { debtAmount: params.debtAmount } : void 0
+    );
+  }
+  async getVesuPositions() {
+    const positions = await this.getAdapterById(
+      "vesu_usdc_strk"
+    ).getPositions();
+    return positions.map((p) => ({
+      amount: p.amount,
+      usdValue: p.usdValue,
+      remarks: p.remarks ?? "",
+      token: p.tokenInfo,
+      protocol: p.protocol
+    }));
+  }
+  async getVesuHealthFactor(blockNumber = "latest") {
+    const vesuAdapter = this.getAdapterById("vesu_usdc_strk");
+    return await vesuAdapter._vesuAdapter.getHealthFactor(blockNumber);
+  }
+  // TODO: will have to still modify for instant withdrawals as of now
+  async getModifyHyperPositionCall(params) {
+    logger.verbose(
+      `${this.getTag()}::getModifyHyperPositionCall isDeposit=${params.isDeposit}, amount=${params.amount}`
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById("hyper_xstrk"),
+      params.isDeposit,
+      params.amount
+    );
+  }
+  async getAvnuSwapCall(params) {
+    logger.verbose(
+      `${this.getTag()}::getAvnuSwapCall isDeposit=${params.isDeposit}, amount=${params.amount}`
+    );
+    return this.buildManageCallFromAdapter(
+      this.getAdapterById("avnu_strk_xstrk"),
+      params.isDeposit,
+      params.amount
+    );
+  }
+  /**
+   * Returns the USDC balance sitting idle inside the vault contract itself.
+   * This balance can offset the required liquidity during withdrawal processing.
+   */
+  async getUnusedBalanceVault() {
+    const collateralToken = this.metadata.additionalInfo.collateralToken;
+    return new ERC20(this.config).balanceOf(
+      collateralToken.address,
+      this.metadata.additionalInfo.vaultAddress,
+      collateralToken.decimals
+    );
+  }
+  /**
+   * Returns the current STRK balance sitting unused in the vault allocator.
+   * This covers STRK from prior borrow cycles that hasn't been swapped yet.
+   */
+  // Technically we can use this or we can even use the avnu-adapter to get the unused debt
+  async getUnusedDebt() {
+    const debtToken = this.metadata.additionalInfo.debtToken;
+    return new ERC20(this.config).balanceOf(
+      debtToken.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      debtToken.decimals
+    );
+  }
+  /**
+   * Returns the xSTRK balance sitting in the vault allocator.
+   * This is non-zero when the previous cycle's request_redeem on the HyperPosition
+   * has been settled — the redeemed xSTRK lands here and is ready to be swapped.
+   */
+  async getxSTRKInVault() {
+    const xstrkToken = Global.getDefaultTokens().find(
+      (t) => t.symbol === "xSTRK"
+    );
+    if (!xstrkToken) {
+      throw new Error(`${this.getTag()}:: xSTRK token not found`);
+    }
+    return new ERC20(this.config).balanceOf(
+      xstrkToken.address.address,
+      this.metadata.additionalInfo.vaultAllocator,
+      xstrkToken.decimals
+    );
+  }
+  /**
+   * Simulates depositing `depositAmount` USDC on Vesu and returns the
+   * incremental STRK that would be borrowed.  Needed to size the AVNU swap
+   * call that is batched together with the Vesu call in the same transaction.
+   */
+  async computeVesuDepositBorrowAmount(depositAmount) {
+    return this.getAdapterById(
+      "vesu_usdc_strk"
+    ).getExpectedDepositDebtDelta(depositAmount);
+  }
+  async computeVesuWithdrawDebtDelta(withdrawAmount) {
+    return this.getAdapterById(
+      "vesu_usdc_strk"
+    ).getExpectedWithdrawDebtDelta(withdrawAmount);
+  }
+  async getPendingHyperAssets() {
+    const xstrkToken = Global.getDefaultTokens().find(
+      (t) => t.symbol === "xSTRK"
+    );
+    const hyperXstrkRedeemNFT = ContractAddr.from(
+      "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095"
+    );
+    return this.getAdapterById(
+      "hyper_xstrk"
+    ).getPendingAssetsFromOwnerNFTMethod(
+      hyperXstrkRedeemNFT,
+      this.metadata.additionalInfo.vaultAllocator,
+      xstrkToken.decimals
+    );
+  }
+  // TODO: rn we are just making these functions in the strategy itself but
+  // later on we will move them to the SVKStrategy for generalization
+  async getUserTVL(user, blockIdentifier = "latest") {
+    const shares = await this.contract.call("balanceOf", [user.address], {
+      blockIdentifier
+    });
+    const assets = await this.contract.call(
+      "convert_to_assets",
+      [uint25623.bnToUint256(shares)],
+      { blockIdentifier }
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const blockNumber = typeof blockIdentifier === "number" || typeof blockIdentifier === "bigint" ? Number(blockIdentifier) : void 0;
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol,
+      blockNumber
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    const price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+  async getAUM() {
+    const underlying = this.asset();
+    const usdcPrice = await this.pricer.getPrice(underlying.symbol);
+    const allPositions = [];
+    for (const adapter of this.metadata.additionalInfo.adapters) {
+      const positions = await adapter.adapter.getPositions();
+      allPositions.push(...positions);
+    }
+    let netAUM = new Web3Number(0, underlying.decimals);
+    for (const position of allPositions) {
+      if (position.tokenInfo.address.eq(underlying.address)) {
+        netAUM = netAUM.plus(position.amount);
+      } else {
+        const valueInUSDC = position.usdValue;
+        netAUM = netAUM.plus(valueInUSDC);
+      }
+    }
+    const unusedBalance = await this.getUnusedBalance();
+    logger.verbose(
+      `${this.getTag()} unused balance: ${unusedBalance.amount.toNumber()}`
+    );
+    netAUM = netAUM.plus(unusedBalance.amount);
+    const prevAum = await this.getPrevAUM();
+    logger.verbose(`${this.getTag()} AUM: ${netAUM}`);
+    const realAUM = {
+      tokenInfo: underlying,
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * usdcPrice.price,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      remarks: "finalised" /* FINALISED */,
+      protocol: Protocols.NONE
+    };
+    const estimatedAUMDelta = {
+      tokenInfo: underlying,
+      amount: Web3Number.fromWei("0", underlying.decimals),
+      usdValue: 0,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      remarks: "defispring" /* DEFISPRING */,
+      protocol: Protocols.NONE
+    };
+    return {
+      net: {
+        tokenInfo: underlying,
+        amount: netAUM,
+        usdValue: netAUM.toNumber() * usdcPrice.price
+      },
+      prevAum,
+      splits: [realAUM, estimatedAUMDelta]
+    };
+  }
+  // TODO: can refactor later but seems redundant since not being used ANYWHERE
+  // Most of the fund management done through adapters only
+  async getFundManagementCall(params) {
+    logger.verbose(
+      `${this.getTag()}::getFundManagementCall params: ${JSON.stringify(params)}`
+    );
+    const allAdapters = this.metadata.additionalInfo.adapters.map(
+      (a) => a.adapter
+    );
+    if (!params.isDeposit) {
+      const unusedBalance = await this.getUnusedBalance();
+      logger.verbose(
+        `${this.getTag()}::getFundManagementCall unusedBalance: ${unusedBalance.amount}, required: ${params.leg1DepositAmount}`
+      );
+      if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
+        return null;
+      }
+      const adapters2 = await AdapterOptimizer.getAdapterToUse(
+        allAdapters,
+        false,
+        params.leg1DepositAmount
+      );
+      if (adapters2.length > 0) {
+        const proofsInfo = adapters2.map(
+          (adapter) => adapter.getProofs(false, this.getMerkleTree())
+        );
+        const calls = [];
+        for (const info of proofsInfo) {
+          const manageCalls = await info.callConstructor({
+            amount: params.leg1DepositAmount
+          });
+          const call = this.getManageCall(
+            this.getProofGroupsForManageCalls(manageCalls),
+            manageCalls
+          );
+          calls.push(call);
+        }
+        return calls;
+      }
+      throw new Error(
+        `${this.getTag()}::getFundManagementCall: no adapters for withdraw: ${unusedBalance.amount}`
+      );
+    }
+    const adapters = await AdapterOptimizer.getAdapterToUse(
+      allAdapters,
+      true,
+      params.leg1DepositAmount
+    );
+    if (adapters.length > 0) {
+      const proofsInfo = adapters.map(
+        (adapter) => adapter.getProofs(true, this.getMerkleTree())
+      );
+      const calls = [];
+      for (const info of proofsInfo) {
+        const manageCalls = await info.callConstructor({
+          amount: params.leg1DepositAmount
+        });
+        const call = this.getManageCall(
+          this.getProofGroupsForManageCalls(manageCalls),
+          manageCalls
+        );
+        calls.push(call);
+      }
+      return calls;
+    }
+    throw new Error(
+      `${this.getTag()}::getFundManagementCall: no adapters for deposit: ${params.leg1DepositAmount}`
+    );
+  }
 };
-function getInvestmentSteps(lstSymbol, underlyingSymbol) {
-  return [
-    `Deposit ${lstSymbol} 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`,
-    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
-  ];
-}
-function getMaxTVL(lstSymbol) {
-  const lstMaxTVLs = {
-    xWBTC: 5,
-    xLBTC: 5,
-    xtBTC: 5,
-    xsBTC: 5,
-    xSTRK: 7e6
+function getUSDCBoostedSettings(vaultSettings) {
+  vaultSettings.leafAdapters = [];
+  const xSTRKToken = Global.getDefaultTokens().find(
+    (t) => t.symbol === "xSTRK"
+  );
+  const USDCToken = Global.getDefaultTokens().find((t) => t.symbol === "USDC");
+  const STRKToken = Global.getDefaultTokens().find((t) => t.symbol === "STRK");
+  const baseAdapterConfig = {
+    baseToken: USDCToken,
+    supportedPositions: [{ asset: USDCToken, isDebt: false }],
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
+    vaultAllocator: vaultSettings.vaultAllocator,
+    vaultAddress: vaultSettings.vaultAddress
   };
-  const maxTVLValue = lstMaxTVLs[lstSymbol] || 0;
-  const token = Global.getDefaultTokens().find(
-    (token2) => token2.symbol === lstSymbol
+  const vesuModifyPositionAdapter = new VesuModifyPositionAdapter({
+    poolId: vaultSettings.vesuPoolId,
+    collateral: vaultSettings.collateralToken,
+    debt: vaultSettings.debtToken,
+    targetLtv: vaultSettings.targetLTV,
+    maxLtv: vaultSettings.maxLTV,
+    ...baseAdapterConfig,
+    supportedPositions: [
+      { asset: USDCToken, isDebt: false },
+      { asset: STRKToken, isDebt: true }
+    ]
+  });
+  const avnuAdapter = new AvnuAdapter({
+    baseUrl: AVNU_QUOTE_URL,
+    avnuContract: AVNU_EXCHANGE,
+    slippage: 0.01,
+    minimumExtendedPriceDifferenceForSwapOpen: 0,
+    maximumExtendedPriceDifferenceForSwapClosing: 0,
+    ...baseAdapterConfig,
+    baseToken: STRKToken,
+    supportedPositions: [
+      { asset: STRKToken, isDebt: false },
+      { asset: xSTRKToken, isDebt: false }
+    ]
+  });
+  const svkTrovesAdapter = new SvkTrovesAdapter({
+    ...baseAdapterConfig,
+    baseToken: xSTRKToken,
+    supportedPositions: [{ asset: xSTRKToken, isDebt: false }],
+    strategyVault: vaultSettings.hyperxSTRKVaultAddress,
+    trovesStrategyId: "hyper_xstrk"
+  });
+  const usdcTransferAdapter = new TokenTransferAdapter({
+    ...baseAdapterConfig,
+    fromAddress: vaultSettings.vaultAllocator,
+    toAddress: vaultSettings.vaultAddress
+  });
+  const commonAdapter = new CommonAdapter({
+    id: "flash_loan_init" /* FLASH_LOAN */,
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    manager: vaultSettings.manager,
+    asset: USDCToken.address
+  });
+  vaultSettings.adapters.push(
+    // TODO: generalize the ids
+    { id: "vesu_usdc_strk", adapter: vesuModifyPositionAdapter },
+    // Used to track swapped funds in vaultAllocator
+    { id: "avnu_strk_xstrk", adapter: avnuAdapter },
+    { id: "hyper_xstrk", adapter: svkTrovesAdapter },
+    { id: "usdc_transfer", adapter: usdcTransferAdapter }
   );
-  if (!token) {
-    return Web3Number.fromWei(0, 18);
-  }
-  return Web3Number.fromWei(maxTVLValue, token.decimals);
-}
-function createHyperLSTSettings(lstSymbol, underlyingSymbol) {
-  const depositToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === lstSymbol
+  vaultSettings.leafAdapters.push(
+    () => vesuModifyPositionAdapter.getDepositLeaf()
   );
-  return {
-    maxTVL: getMaxTVL(lstSymbol),
-    isPaused: false,
-    liveStatus: "Hot & New \u{1F525}" /* HOT */,
-    isAudited: true,
-    isInstantWithdrawal: false,
-    hideHarvestInfo: true,
-    quoteToken: depositToken,
-    showWithdrawalWarningModal: false,
-    alerts: [
-      {
-        tab: "withdraw",
-        text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 24 hours (In this initial phase of Launch). You can monitor the status in transactions tab.",
-        type: "info"
-      },
-      {
-        tab: "deposit",
-        text: /* @__PURE__ */ jsxs4(Fragment3, { children: [
-          "To acquire the LST, please visit",
-          " ",
-          /* @__PURE__ */ jsx5("a", { href: "https://app.endur.fi", target: "_blank", rel: "noopener noreferrer", children: "endur.fi" })
-        ] }),
-        type: "info"
-      },
-      {
-        tab: "deposit",
-        text: "It may take up to one week for your deposit to appreciate in value. This delay occurs because the LST price is sourced from DEXes and liquidity is usually rebased once a week.",
-        type: "info"
-      }
-    ]
-  };
+  vaultSettings.leafAdapters.push(
+    () => vesuModifyPositionAdapter.getWithdrawLeaf()
+  );
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => svkTrovesAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(
+    commonAdapter.getApproveAdapter(
+      USDCToken.address,
+      vaultSettings.vaultAddress,
+      "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */
+    ).bind(commonAdapter)
+  );
+  vaultSettings.leafAdapters.push(
+    commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter)
+  );
+  return vaultSettings;
 }
-var HYPER_LST_SECURITY = {
-  auditStatus: "Audited" /* AUDITED */,
-  sourceCode: {
-    type: "Closed Source" /* CLOSED_SOURCE */,
-    contractLink: "https://github.com/trovesfi/troves-contracts"
-  },
-  accessControl: {
-    type: "Standard Account" /* STANDARD_ACCOUNT */,
-    addresses: [ContractAddr.from("0x0")],
-    timeLock: "2 Days"
-  }
-};
-var HYPER_LST_REDEMPTION_INFO = {
-  instantWithdrawalVault: "No" /* NO */,
-  redemptionsInfo: [
-    {
-      title: "Typical Duration",
-      description: "1-2 hours"
-    }
-  ],
-  alerts: [
-    {
-      type: "info",
-      text: "In cases of low liquidity, high slippages, the redemptions can take longer time. Redemption times are estimates and may vary based on network conditions and liquidity requirements.",
-      tab: "withdraw"
-    }
-  ]
+var usdcBoostedSettings = {
+  vaultAddress: ContractAddr.from(
+    "0xcdb0e3b2e076a2cdc4ee958b726b47c066239ef91c5ac80c94cf814147b84"
+  ),
+  manager: ContractAddr.from(
+    "0x72eea9bac9fa8cfffda637d3b990851446860c6fd8987d6cb50e659b01ee50f"
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x6d3101cff7f821412a99ebe23bb31a1950f93276285102eb4313e3601f5f927"
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x47dcc6889ca8db4e9eea8f55421e10f8ce7e356ccb45260a1c49a76f733c309"
+  ),
+  // TODO: not applicable in our case -> remove later ( make it optional if needed)
+  aumOracle: ContractAddr.from("0x0"),
+  leafAdapters: [],
+  adapters: [],
+  // Calc using the maxLTV / targetLTV (0.5)
+  targetHealthFactor: 1.32,
+  // Calc using the maxLTV / maxAcceptableLTV (0.55)
+  minHealthFactor: 1.2,
+  vesuPoolId: VesuPools.Prime,
+  collateralToken: Global.getDefaultTokens().find((t) => t.symbol === "USDC"),
+  debtToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK"),
+  maxLTV: 0.66,
+  targetLTV: 0.5,
+  hyperxSTRKVaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960"
+  )
 };
-function getStrategySettings(lstSymbol, underlyingSymbol, settings, isPreview = false, isLST) {
+function getStrategySettings2(settings) {
+  const USDCToken = Global.getDefaultTokens().find((t) => t.symbol === "USDC");
+  const STRKToken = Global.getDefaultTokens().find((t) => t.symbol === "STRK");
   return {
-    id: `hyper_${lstSymbol.toLowerCase()}`,
-    name: `Hyper ${lstSymbol}`,
-    description: getDescription2(lstSymbol, underlyingSymbol),
+    id: "usdc_boosted",
+    name: "USDC Boosted",
+    description: "Deposits USDC as collateral on Vesu, borrows STRK, swaps to xSTRK, and deposits into Hyper-xSTRK for boosted yield",
     address: settings.vaultAddress,
-    launchBlock: 0,
-    type: "Other",
+    launchBlock: 8742931,
+    type: "ERC4626",
     vaultType: {
-      type: "Looping" /* LOOPING */,
-      description: `Creates leveraged looping position on ${lstSymbol} by borrowing ${underlyingSymbol} to increase yield`
+      // TODO: can change as per need
+      type: "Meta Vault" /* META_VAULT */,
+      description: "Deposits USDC as collateral on Vesu, borrows STRK, swaps to xSTRK, and deposits into Hyper-xSTRK for boosted yield"
     },
-    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === lstSymbol)],
-    additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, settings, lstSymbol === "xSTRK" ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
+    depositTokens: [USDCToken],
+    additionalInfo: getUSDCBoostedSettings(settings),
+    // TODO: config lateron
     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)
+      riskFactor: [],
+      netRisk: 0,
+      notARisks: []
     },
-    auditUrl: AUDIT_URL4,
-    protocols: [Protocols.ENDUR, Protocols.VESU],
+    protocols: [Protocols.VESU, Protocols.TROVES],
     curator: {
       name: "Unwrap Labs",
       logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
     },
-    settings: createHyperLSTSettings(lstSymbol, underlyingSymbol),
+    settings: {
+      maxTVL: Web3Number.fromWei(0, USDCToken.decimals),
+      isPaused: false,
+      isAudited: false,
+      isInstantWithdrawal: false,
+      hideHarvestInfo: true,
+      quoteToken: USDCToken,
+      alerts: [
+        {
+          tab: "withdraw",
+          text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 1-2 hours. You can monitor the status in transactions tab.",
+          type: "info"
+        }
+      ]
+    },
     contractDetails: getContractDetails(settings),
-    faqs: getFAQs2(lstSymbol, underlyingSymbol, isLST),
-    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
-    isPreview,
-    apyMethodology: "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
-    realizedAPYMethodology: "The realizedAPY is based on past 14 days performance by the vault",
-    tags: lstSymbol.includes("BTC") ? ["BTC" /* BTC */, "Maxx" /* LEVERED */] : ["Maxx" /* LEVERED */],
-    security: HYPER_LST_SECURITY,
-    redemptionInfo: HYPER_LST_REDEMPTION_INFO,
-    usualTimeToEarnings: "2 weeks",
-    usualTimeToEarningsDescription: "Strategy returns depend on LST price on DEXes. Even though the true price of LST on Endur increases continuously, the DEX price may lag sometimes, and historically is seen to rebase at least once every 2 hours. This is when you realise your earnings.",
-    points: lstSymbol === "xSTRK" ? [{
-      multiplier: 4,
-      logo: "https://endur.fi/favicon.ico",
-      toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi."
-    }] : void 0
+    // TODO: config later
+    faqs: [],
+    investmentSteps: [
+      "Deposit USDC into the vault",
+      "USDC is supplied as collateral on Vesu, STRK is borrowed",
+      "Borrowed STRK is swapped to xSTRK via Avnu",
+      "xSTRK is deposited into the Hyper-xSTRK vault for additional yield",
+      "On withdrawal, the pipeline reverses to return USDC"
+    ],
+    // TODO: config later
+    tags: ["Meta Vaults" /* META_VAULT */],
+    security: {
+      auditStatus: "Audited" /* AUDITED */,
+      sourceCode: {
+        type: "Closed Source" /* CLOSED_SOURCE */,
+        contractLink: "https://github.com/trovesfi/troves-contracts"
+      },
+      accessControl: {
+        type: "Standard Account" /* STANDARD_ACCOUNT */,
+        addresses: [ContractAddr.from("0x0")],
+        timeLock: "2 Days"
+      }
+    },
+    redemptionInfo: {
+      instantWithdrawalVault: "No" /* NO */,
+      redemptionsInfo: [
+        {
+          title: "Typical Duration",
+          description: "1-2 hours"
+        }
+      ],
+      alerts: [
+        {
+          type: "info",
+          text: "Redemption times are estimates and may vary based on network conditions and liquidity requirements.",
+          tab: "withdraw"
+        }
+      ]
+    },
+    usualTimeToEarnings: null,
+    usualTimeToEarningsDescription: null
   };
 }
-var HyperLSTStrategies = [
-  getStrategySettings("xSTRK", "STRK", hyperxSTRK, false, true),
-  getStrategySettings("xWBTC", "WBTC", hyperxWBTC, false, false),
-  getStrategySettings("xtBTC", "tBTC", hyperxtBTC, false, false),
-  getStrategySettings("xsBTC", "solvBTC", hyperxsBTC, false, false),
-  getStrategySettings("xLBTC", "LBTC", hyperxLBTC, false, false),
-  getStrategySettings("mRe7BTC", "mRe7BTC", hypermRe7BTC, false, false),
-  getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
-];
+var USDCBoostedStrategies = [getStrategySettings2(usdcBoostedSettings)];
 
 // src/strategies/vesu-extended-strategy/services/ltv-imbalance-rebalance-math.ts
 function ceilBtc(v, precision) {
@@ -45621,7 +47041,7 @@ var ExtendedSVKVesuStateManager = class {
 };
 
 // src/strategies/vesu-extended-strategy/services/executionService.ts
-import { uint256 as uint25623 } from "starknet";
+import { uint256 as uint25624 } from "starknet";
 
 // src/strategies/vesu-extended-strategy/types/transaction-metadata.ts
 var CycleType = /* @__PURE__ */ ((CycleType2) => {
@@ -46553,7 +47973,7 @@ var _ExecutionService = class _ExecutionService {
     const extendedContract = extendedAdapter.config.extendedContract;
     const vaultId = extendedAdapter.config.vaultIdExtended;
     const salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
-    const uint256Amount = uint25623.bnToUint256(amount.toWei());
+    const uint256Amount = uint25624.bnToUint256(amount.toWei());
     const approveCall = {
       contractAddress: usdcToken.address.address,
       entrypoint: "approve",
@@ -48509,7 +49929,7 @@ var PricerRedis = class extends Pricer {
 };
 
 // src/node/deployer.ts
-import assert2 from "assert";
+import assert3 from "assert";
 import { Deployer as SnDeployer, TransactionExecutionStatus, constants as constants3, extractContractHashes, json, num as num14 } from "starknet";
 import { readFileSync as readFileSync2, existsSync, writeFileSync as writeFileSync2 } from "fs";
 
@@ -48778,8 +50198,8 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
       classHash,
       constructorCalldata: constructorData
     }, acc.address);
-    assert2(calls.length == 1, `Expected exactly one call, got ${calls.length}`);
-    assert2(addresses.length == 1, `Expected exactly one address, got ${addresses.length}`);
+    assert3(calls.length == 1, `Expected exactly one call, got ${calls.length}`);
+    assert3(addresses.length == 1, `Expected exactly one address, got ${addresses.length}`);
     result.push({
       contract_name,
       package_name,
@@ -48792,7 +50212,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
 }
 async function executeDeployCalls(contractsInfo, acc, provider2) {
   for (let contractInfo of contractsInfo) {
-    assert2(num14.toHexString(contractInfo.call.contractAddress) == num14.toHexString(constants3.UDC.ADDRESS), "Must be pointed at UDC address");
+    assert3(num14.toHexString(contractInfo.call.contractAddress) == num14.toHexString(constants3.UDC.ADDRESS), "Must be pointed at UDC address");
   }
   const allCalls = contractsInfo.map((info) => info.call);
   await executeTransactions(allCalls, acc, provider2, `Deploying contracts: ${contractsInfo.map((info) => info.contract_name).join(", ")}`);
@@ -48936,6 +50356,7 @@ export {
   SIMPLE_SANITIZER,
   SIMPLE_SANITIZER_V2,
   SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+  SVK_SIMPLE_SANITIZER,
   SenseiStrategies,
   SenseiVault,
   SolveBudget,
@@ -48955,6 +50376,8 @@ export {
   TokenTransferAdapter,
   UNIVERSAL_ADAPTERS,
   UNIVERSAL_MANAGE_IDS,
+  USDCBoostedStrategies,
+  USDCBoostedStrategy,
   UniversalLstMultiplierStrategy,
   UniversalStrategies,
   UniversalStrategy,