@strkfarm/sdk 2.0.0-dev.33 → 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,228 +39054,1076 @@ 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(),
+        name: "nominal",
+        type: "core::integer::u256"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "vault::redeem_request::interface::IRedeemRequest",
+    items: [
+      {
+        type: "function",
+        name: "vault",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "id_to_info",
+        inputs: [
+          {
+            name: "id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "vault::redeem_request::interface::RedeemRequestInfo"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "id_len",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "mint",
+        inputs: [
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "redeem_request_info",
+            type: "vault::redeem_request::interface::RedeemRequestInfo"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "burn",
+        inputs: [
+          {
+            name: "id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      }
+    ]
+  },
+  {
+    type: "impl",
+    name: "UpgradeableImpl",
+    interface_name: "openzeppelin_interfaces::upgrades::IUpgradeable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_interfaces::upgrades::IUpgradeable",
+    items: [
+      {
+        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::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "core::bool",
+    variants: [
+      {
+        name: "False",
+        type: "()"
+      },
+      {
+        name: "True",
+        type: "()"
+      }
+    ]
+  },
+  {
+    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: "openzeppelin_interfaces::token::erc721::ERC721ABI",
+    items: [
+      {
+        type: "function",
+        name: "balance_of",
+        inputs: [
+          {
+            name: "account",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "owner_of",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "safe_transfer_from",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "transfer_from",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        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: "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: "get_approved",
+        inputs: [
+          {
+            name: "token_id",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "is_approved_for_all",
+        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: "supports_interface",
+        inputs: [
+          {
+            name: "interface_id",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "name",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "symbol",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::byte_array::ByteArray"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "token_uri",
+        inputs: [
+          {
+            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"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "ownerOf",
+        inputs: [
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "safeTransferFrom",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          },
+          {
+            name: "data",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "transferFrom",
+        inputs: [
+          {
+            name: "from",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "to",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "tokenId",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "setApprovalForAll",
+        inputs: [
+          {
+            name: "operator",
+            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: "ERC721EnumerableImpl",
+    interface_name: "openzeppelin_interfaces::token::erc721::IERC721Enumerable"
+  },
+  {
+    type: "interface",
+    name: "openzeppelin_interfaces::token::erc721::IERC721Enumerable",
+    items: [
+      {
+        type: "function",
+        name: "total_supply",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        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: "constructor",
+    name: "constructor",
+    inputs: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "vault",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
+    kind: "struct",
+    members: [
+      {
+        name: "from",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "to",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
+    kind: "struct",
+    members: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "approved",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "token_id",
+        type: "core::integer::u256",
+        kind: "key"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::ApprovalForAll",
+    kind: "struct",
+    members: [
+      {
+        name: "owner",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "operator",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "approved",
+        type: "core::bool",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "Transfer",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Transfer",
+        kind: "nested"
+      },
+      {
+        name: "Approval",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Approval",
+        kind: "nested"
+      },
+      {
+        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",
+    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: "vault::redeem_request::redeem_request::RedeemRequest::Event",
+    kind: "enum",
+    variants: [
+      {
+        name: "ERC721Event",
+        type: "openzeppelin_token::erc721::erc721::ERC721Component::Event",
+        kind: "flat"
+      },
+      {
+        name: "ERC721EnumerableEvent",
+        type: "openzeppelin_token::erc721::extensions::erc721_enumerable::erc721_enumerable::ERC721EnumerableComponent::Event",
+        kind: "flat"
+      },
+      {
+        name: "SRC5Event",
+        type: "openzeppelin_introspection::src5::SRC5Component::Event",
+        kind: "flat"
+      },
+      {
+        name: "UpgradeableEvent",
+        type: "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
+        kind: "flat"
+      }
+    ]
+  }
+];
+
+// 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 getPendingAssetsFromOwner(owner = this._positionOwner(), decimals = this.config.baseToken.decimals) {
+    const vault = new Contract14({
+      abi: universal_vault_abi_default,
+      address: this.config.strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider
+    });
+    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);
+    }
+  }
+  /**
+   * 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 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 [
+      {
+        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()
+      }
+    ];
+  }
+  _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()
+      }
+    ];
+  }
+  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 [
+      {
+        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,
@@ -39250,16 +40143,23 @@ var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
     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 sharesRaw = await vault.convert_to_shares(uint256Amount);
+    const sharesU256 = uint25619.bnToUint256(sharesRaw.toString());
     return [
       {
         proofReadableId: this._withdrawCallProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
+        sanitizer: SVK_SIMPLE_SANITIZER,
         call: {
           contractAddress: strategyVault,
-          selector: hash11.getSelectorFromName("withdraw"),
+          selector: hash11.getSelectorFromName("request_redeem"),
           calldata: [
-            toBigInt(uint256Amount.low.toString()),
-            toBigInt(uint256Amount.high.toString()),
+            toBigInt(sharesU256.low.toString()),
+            toBigInt(sharesU256.high.toString()),
             recv.toBigInt(),
             owner.toBigInt()
           ]
@@ -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
@@ -42148,95 +43048,615 @@ function createHyperLSTSettings(lstSymbol, underlyingSymbol) {
         ] }),
         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"
+      {
+        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"
+    }
+  ]
+};
+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]
+    };
   }
-};
-var HYPER_LST_REDEMPTION_INFO = {
-  instantWithdrawalVault: "No" /* NO */,
-  redemptionsInfo: [
-    {
-      title: "Typical Duration",
-      description: "1-2 hours"
+  // 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}`
+      );
     }
-  ],
-  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"
+    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 getStrategySettings(lstSymbol, underlyingSymbol, settings, isPreview = false, isLST) {
+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 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 }
+  );
+  vaultSettings.leafAdapters.push(
+    () => vesuModifyPositionAdapter.getDepositLeaf()
+  );
+  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 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 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) {
@@ -43635,6 +45055,142 @@ function createSolveBudgetFromRawState(params) {
   }
   return budget;
 }
+function assertRouteSanityAndAdjust(route, availableAmount) {
+  if (!route.amount) {
+    throw new Error(`Invalid route given to assertRouteSanityAndAdjust: ${JSON.stringify(route)}`);
+  }
+  const routeAmount = route.amount.toNumber();
+  if (routeAmount <= availableAmount) {
+    return route;
+  }
+  if (routeAmount - availableAmount <= CASE_THRESHOLD_USD) {
+    return { ...route, amount: new Web3Number(availableAmount, route.amount.decimals) };
+  }
+  throw new Error(`Route amount ${routeAmount} exceeds available amount ${availableAmount}, Route name: ${route.type}`);
+}
+function assertVesuMultiplyRouteSanityAndAdjust(route, availableAmount, state, isIncrease) {
+  const btcPrice = state.vesuPoolState.collateralPrice;
+  const totalCollateralAmount = isIncrease ? route.marginAmount.plus(route.swappedCollateralAmount).plus(state.vesuPoolState.collateralAmount) : state.vesuPoolState.collateralAmount.minus(route.marginAmount.plus(route.swappedCollateralAmount));
+  const totalDebtAmount = isIncrease ? route.debtAmount.plus(state.vesuPoolState.debtAmount) : state.vesuPoolState.debtAmount.minus(route.debtAmount);
+  const newHF = HealthFactorMath.getHealthFactor(
+    totalCollateralAmount,
+    btcPrice,
+    VesuConfig.maxLtv,
+    totalDebtAmount,
+    state.vesuPoolState.debtPrice
+  );
+  const idealHF = VesuConfig.maxLtv / VesuConfig.targetLtv - 0.05;
+  assert(newHF >= idealHF, `SolveBudget::applyRoutesAndVerifyLtvState newHF=${newHF} < idealHF=${idealHF}`);
+}
+function applyRoutesAndVerifyLtvState(state, routes) {
+  const btcPrice = state.vesuPoolState.collateralPrice;
+  const adjustedRouters = [...routes];
+  let index = 0;
+  for (const r of routes) {
+    switch (r.type) {
+      case "WALLET_TO_VA" /* WALLET_TO_VA */: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.walletUsd);
+        const amt = adjustedRoute.amount.toNumber();
+        state.spendWallet(amt);
+        state.addToVA(amt);
+        break;
+      }
+      case "VESU_REPAY" /* VESU_REPAY */: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.vaRawUsd);
+        const amt = Math.abs(adjustedRoute.amount.toNumber());
+        state.repayVesuBorrowCapacity(amt);
+        state.spendVA(amt);
+        break;
+      }
+      case "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.extAvailWithdraw);
+        const amt = adjustedRoute.amount.toNumber();
+        state.addToWallet(amt);
+        state.spendExtAvailTrade(amt);
+        break;
+      }
+      case "REALISE_PNL" /* REALISE_PNL */: {
+        const amt = r.amount.toNumber();
+        state.spendExtAvailUpnl(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case "VA_TO_EXTENDED" /* VA_TO_EXTENDED */: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.vaRawUsd);
+        const amt = adjustedRoute.amount.toNumber();
+        state.spendVA(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case "WALLET_TO_EXTENDED" /* WALLET_TO_EXTENDED */: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.walletUsd);
+        const amt = adjustedRoute.amount.toNumber();
+        state.spendWallet(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case "VESU_BORROW" /* VESU_BORROW */: {
+        const borrowedAmount = r.amount.toNumber();
+        const currentCollateralAmount = state.vesuPoolState.collateralAmount.toNumber();
+        const currentDebtAmount = state.vesuPoolState.debtAmount.toNumber();
+        const maxDebtAmount = HealthFactorMath.getMaxDebtAmount(
+          new Web3Number(currentCollateralAmount, state.vesuPoolState.collateralToken.decimals),
+          state.vesuPoolState.collateralPrice,
+          VesuConfig.maxLtv,
+          VesuConfig.maxLtv / VesuConfig.targetLtv - 0.05,
+          // e.g. if ideal HF is 1.4, upto 1.35 is ok.
+          state.vesuPoolState.debtPrice,
+          state.vesuPoolState.debtToken
+        );
+        const availableDebtAmount = maxDebtAmount.minus(new Web3Number(currentDebtAmount, state.vesuPoolState.debtToken.decimals));
+        if (!availableDebtAmount.plus(CASE_THRESHOLD_USD).greaterThan(borrowedAmount)) {
+          throw new Error(`SolveBudget::applyRoutesAndVerifyLtvState availableDebtAmount=${availableDebtAmount.toNumber()} < borrowedAmount=${borrowedAmount}`);
+        }
+        state.spendVesuBorrowCapacity(borrowedAmount);
+        state.addToVA(borrowedAmount);
+        break;
+      }
+      case "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */: {
+        const mr = r;
+        assertVesuMultiplyRouteSanityAndAdjust(mr, state.vaRawUsd, state, true);
+        state.applyVesuDelta(
+          mr.poolId,
+          mr.collateralToken,
+          mr.debtToken,
+          mr.marginAmount.plus(mr.swappedCollateralAmount),
+          mr.debtAmount
+        );
+        state.spendVA(mr.marginAmount.toNumber() * btcPrice);
+        break;
+      }
+      case "VESU_MULTIPLY_DECREASE_LEVER" /* VESU_MULTIPLY_DECREASE_LEVER */: {
+        const mr = r;
+        assertVesuMultiplyRouteSanityAndAdjust(mr, state.vaRawUsd, state, false);
+        state.applyVesuDelta(
+          mr.poolId,
+          mr.collateralToken,
+          mr.debtToken,
+          new Web3Number(mr.marginAmount.negated().minus(mr.swappedCollateralAmount).toFixed(8), mr.marginAmount.decimals),
+          mr.debtAmount
+        );
+        const marginBtc = mr.marginAmount.toNumber();
+        if (marginBtc > 10 ** -COLLATERAL_PRECISION) {
+          state.addToVA(marginBtc * btcPrice);
+        }
+        break;
+      }
+      case "EXTENDED_DECREASE_LEVER" /* EXTENDED_DECREASE_LEVER */:
+      case "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */: {
+        const er = r;
+        state.applyExtendedExposureDelta(er.instrument, er.amount, btcPrice);
+        break;
+      }
+      case "RETURN_TO_WAIT" /* RETURN_TO_WAIT */:
+        break;
+    }
+    index++;
+  }
+}
 var ExtendedSVKVesuStateManager = class {
   constructor(config) {
     this._tag = "ExtendedSVKVesuStateManager";
@@ -43653,13 +45209,19 @@ var ExtendedSVKVesuStateManager = class {
    *   Pass 0 (default) for normal investment / rebalancing cycles.
    */
   async solve(withdrawAmount = new Web3Number(0, USDC_TOKEN_DECIMALS)) {
-    await this._refresh();
+    const gaurdrailBudget = await this._refresh();
     if (Math.abs(this._budget.extPendingDeposit) > 0) {
       logger.warn(`${this._tag}::solve extPendingDeposit=${this._budget.extPendingDeposit}`);
       return null;
     }
     this._validateRefreshedState();
     const cases = this._classifyCases(withdrawAmount);
+    for (const c of cases) {
+      applyRoutesAndVerifyLtvState(gaurdrailBudget, c.routes);
+    }
+    const extendedPositionSize = gaurdrailBudget.extendedPositionsView[0].size.toNumber();
+    const vesuPositionSize = gaurdrailBudget.vesuPoolState.collateralAmount.toNumber();
+    assert(Math.abs(extendedPositionSize - vesuPositionSize) <= 1e-5, "extended positions size mismatch");
     const result = {
       cases,
       // ignore these fields for now. only cases are relevant.
@@ -43707,7 +45269,7 @@ var ExtendedSVKVesuStateManager = class {
       vaultUsdcBalance,
       walletBalance
     );
-    this._budget = createSolveBudgetFromRawState({
+    const data = {
       assetToken: this._config.assetToken,
       usdcToken: this._config.usdcToken,
       unusedBalance,
@@ -43724,7 +45286,9 @@ var ExtendedSVKVesuStateManager = class {
         pendingDeposit: extendedBalance?.pendingDeposit || new Web3Number(0, USDC_TOKEN_DECIMALS)
       },
       vesuPoolStates
-    });
+    };
+    this._budget = createSolveBudgetFromRawState(data);
+    const gaurdrailBudget = createSolveBudgetFromRawState({ ...data });
     this._budget.logStateSummary();
     const totalUnusedUsd = unusedBalance.reduce(
       (acc, b) => acc + b.usdValue,
@@ -43733,6 +45297,7 @@ var ExtendedSVKVesuStateManager = class {
     logger.info(
       `${this._tag}::_refresh completed \u2014 unusedBalances: ${unusedBalance.length} tokens [${unusedBalance.map((b) => `${b.token.symbol}=$${b.usdValue.toFixed(2)}`).join(", ")}], totalUnusedUsd: ${totalUnusedUsd.toFixed(2)}, extendedPositions: ${extendedPositions.length} [${extendedPositions.map((p) => `${p.instrument}=${p.size.toFixed(6)} ${p.side}, ${p.valueUsd.toFixed(6)} ${p.instrument}`).join(", ")}], vesuPools: ${vesuPoolStates.length} [${vesuPoolStates.map((p) => `${p.poolId.shortString()}=${p.debtAmount.toFixed(6)} ${p.debtToken.symbol}, ${p.collateralAmount.toFixed(6)} ${p.collateralToken.symbol}`).join(", ")}], availableForTrade: ${extendedBalance?.availableForTrade.toNumber()} - availableForWithdrawal: ${extendedBalance?.availableForWithdrawal.toNumber()} - unrealisedPnl: ${extendedBalance?.unrealisedPnl.toNumber()} - extendedBalance::balance: ${extendedBalance?.balance.toNumber()} - extendedBalance::pendingDeposit: ${extendedBalance?.pendingDeposit.toNumber()} - extendedBalance::equity: ${extendedBalance?.equity.toNumber()}`
     );
+    return gaurdrailBudget;
   }
   // todo add communication check with python server of extended. if not working, throw error in solve function.
   /** True when strategy asset and USDC share one token — VA idle balance is tracked as USDC, not as asset. */
@@ -45476,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) => {
@@ -46408,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",
@@ -48364,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";
 
@@ -48633,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,
@@ -48647,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(", ")}`);
@@ -48791,6 +50356,7 @@ export {
   SIMPLE_SANITIZER,
   SIMPLE_SANITIZER_V2,
   SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+  SVK_SIMPLE_SANITIZER,
   SenseiStrategies,
   SenseiVault,
   SolveBudget,
@@ -48810,6 +50376,8 @@ export {
   TokenTransferAdapter,
   UNIVERSAL_ADAPTERS,
   UNIVERSAL_MANAGE_IDS,
+  USDCBoostedStrategies,
+  USDCBoostedStrategy,
   UniversalLstMultiplierStrategy,
   UniversalStrategies,
   UniversalStrategy,