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

package/dist/index.js

@@ -106,6 +106,7 @@ __export(index_exports, {
   SIMPLE_SANITIZER: () => SIMPLE_SANITIZER,
   SIMPLE_SANITIZER_V2: () => SIMPLE_SANITIZER_V2,
   SIMPLE_SANITIZER_VESU_V1_DELEGATIONS: () => SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+  SVK_SIMPLE_SANITIZER: () => SVK_SIMPLE_SANITIZER,
   SenseiStrategies: () => SenseiStrategies,
   SenseiVault: () => SenseiVault,
   SolveBudget: () => SolveBudget,
@@ -125,6 +126,8 @@ __export(index_exports, {
   TokenTransferAdapter: () => TokenTransferAdapter,
   UNIVERSAL_ADAPTERS: () => UNIVERSAL_ADAPTERS,
   UNIVERSAL_MANAGE_IDS: () => UNIVERSAL_MANAGE_IDS,
+  USDCBoostedStrategies: () => USDCBoostedStrategies,
+  USDCBoostedStrategy: () => USDCBoostedStrategy,
   UniversalLstMultiplierStrategy: () => UniversalLstMultiplierStrategy,
   UniversalStrategies: () => UniversalStrategies,
   UniversalStrategy: () => UniversalStrategy,
@@ -21932,6 +21935,7 @@ var import_starknet19 = require("starknet");
 
 // 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");
@@ -35795,7 +35799,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)
@@ -35813,8 +35824,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
@@ -36011,6 +36022,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
@@ -36568,6 +36597,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) {
@@ -39207,6 +39255,760 @@ var universal_vault_abi_default = [
   }
 ];
 
+// 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: [
+      {
+        name: "low",
+        type: "core::integer::u128"
+      },
+      {
+        name: "high",
+        type: "core::integer::u128"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "vault::redeem_request::interface::RedeemRequestInfo",
+    members: [
+      {
+        name: "epoch",
+        type: "core::integer::u256"
+      },
+      {
+        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) {
@@ -39320,6 +40122,100 @@ var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
       throw error;
     }
   }
+  async getPendingAssetsFromOwner(owner = this._positionOwner(), decimals = this.config.baseToken.decimals) {
+    const vault = new import_starknet30.Contract({
+      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 import_starknet30.Contract({
+        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 = import_starknet30.uint256.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 = import_starknet30.uint256.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) {
@@ -39384,9 +40280,9 @@ var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
     return [
       {
         target: strategyVault,
-        method: "withdraw",
+        method: "request_redeem",
         packedArguments: [recv.toBigInt(), owner.toBigInt()],
-        sanitizer: SIMPLE_SANITIZER,
+        sanitizer: SVK_SIMPLE_SANITIZER,
         id: this._withdrawCallProofReadableId()
       }
     ];
@@ -39448,16 +40344,23 @@ var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
     const uint256Amount = import_starknet30.uint256.bnToUint256(amount.toWei());
     const recv = this.config.vaultAllocator;
     const owner = this.config.vaultAllocator;
+    const vault = new import_starknet30.Contract({
+      abi: universal_vault_abi_default,
+      address: strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider
+    });
+    const sharesRaw = await vault.convert_to_shares(uint256Amount);
+    const sharesU256 = import_starknet30.uint256.bnToUint256(sharesRaw.toString());
     return [
       {
         proofReadableId: this._withdrawCallProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
+        sanitizer: SVK_SIMPLE_SANITIZER,
         call: {
           contractAddress: strategyVault,
-          selector: import_starknet30.hash.getSelectorFromName("withdraw"),
+          selector: import_starknet30.hash.getSelectorFromName("request_redeem"),
           calldata: [
-            toBigInt(uint256Amount.low.toString()),
-            toBigInt(uint256Amount.high.toString()),
+            toBigInt(sharesU256.low.toString()),
+            toBigInt(sharesU256.high.toString()),
             recv.toBigInt(),
             owner.toBigInt()
           ]
@@ -41242,9 +42145,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
@@ -42436,6 +43339,526 @@ var HyperLSTStrategies = [
   getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
 ];
 
+// src/strategies/usdc-boosted-strategy.tsx
+var import_starknet34 = require("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",
+      [import_starknet34.uint256.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 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: "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: 8742931,
+    type: "ERC4626",
+    vaultType: {
+      // 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: [USDCToken],
+    additionalInfo: getUSDCBoostedSettings(settings),
+    // TODO: config lateron
+    risk: {
+      riskFactor: [],
+      netRisk: 0,
+      notARisks: []
+    },
+    protocols: [Protocols.VESU, Protocols.TROVES],
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
+    },
+    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),
+    // 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 USDCBoostedStrategies = [getStrategySettings2(usdcBoostedSettings)];
+
 // src/strategies/vesu-extended-strategy/services/ltv-imbalance-rebalance-math.ts
 function ceilBtc(v, precision) {
   const f = 10 ** precision;
@@ -45819,7 +47242,7 @@ var ExtendedSVKVesuStateManager = class {
 };
 
 // src/strategies/vesu-extended-strategy/services/executionService.ts
-var import_starknet34 = require("starknet");
+var import_starknet35 = require("starknet");
 
 // src/strategies/vesu-extended-strategy/types/transaction-metadata.ts
 var CycleType = /* @__PURE__ */ ((CycleType2) => {
@@ -46751,7 +48174,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 = import_starknet34.uint256.bnToUint256(amount.toWei());
+    const uint256Amount = import_starknet35.uint256.bnToUint256(amount.toWei());
     const approveCall = {
       contractAddress: usdcToken.address.address,
       entrypoint: "approve",
@@ -48708,12 +50131,12 @@ var PricerRedis = class extends Pricer {
 
 // src/node/deployer.ts
 var import_assert = __toESM(require("assert"));
-var import_starknet36 = require("starknet");
+var import_starknet37 = require("starknet");
 var import_fs3 = require("fs");
 
 // src/utils/store.ts
 var import_fs2 = __toESM(require("fs"));
-var import_starknet35 = require("starknet");
+var import_starknet36 = require("starknet");
 var crypto2 = __toESM(require("crypto"));
 
 // src/utils/encrypt.ts
@@ -48807,7 +50230,7 @@ var Store = class _Store {
     }
     logger.verbose(`Account loaded: ${accountKey} from network: ${this.config.network}`);
     logger.verbose(`Address: ${data.address}`);
-    const acc = new import_starknet35.Account({
+    const acc = new import_starknet36.Account({
       provider: this.config.provider,
       address: data.address,
       signer: data.pk,
@@ -48902,10 +50325,10 @@ function getAccount(accountKey, config, password = process.env.ACCOUNT_SECURE_PA
 }
 async function myDeclare(contract_name, package_name = "strkfarm", config, acc) {
   const provider2 = config.provider;
-  const compiledSierra = import_starknet36.json.parse(
+  const compiledSierra = import_starknet37.json.parse(
     (0, import_fs3.readFileSync)(`./target/release/${package_name}_${contract_name}.contract_class.json`).toString("ascii")
   );
-  const compiledCasm = import_starknet36.json.parse(
+  const compiledCasm = import_starknet37.json.parse(
     (0, import_fs3.readFileSync)(`./target/release/${package_name}_${contract_name}.compiled_contract_class.json`).toString("ascii")
   );
   const contracts = getContracts();
@@ -48913,7 +50336,7 @@ async function myDeclare(contract_name, package_name = "strkfarm", config, acc)
     contract: compiledSierra,
     casm: compiledCasm
   };
-  const result = (0, import_starknet36.extractContractHashes)(payload);
+  const result = (0, import_starknet37.extractContractHashes)(payload);
   console.log("classhash:", result.classHash);
   try {
     const cls = await provider2.getClassByHash(result.classHash);
@@ -48931,7 +50354,7 @@ async function myDeclare(contract_name, package_name = "strkfarm", config, acc)
   const tx = await acc.declareIfNot(payload);
   console.log(`Declaring: ${contract_name}, tx:`, tx.transaction_hash);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet36.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet37.TransactionExecutionStatus.SUCCEEDED]
   });
   if (!contracts.class_hashes) {
     contracts["class_hashes"] = {};
@@ -48955,7 +50378,7 @@ async function deployContract(contract_name, classHash, constructorData, config,
   });
   console.log("Deploy tx: ", tx.transaction_hash);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet36.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet37.TransactionExecutionStatus.SUCCEEDED]
   });
   const contracts = getContracts();
   if (!contracts.contracts) {
@@ -48972,7 +50395,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
   for (const { contract_name, package_name, constructorData } of contracts) {
     const declaredInfo = await myDeclare(contract_name, package_name, config, acc);
     const classHash = declaredInfo.class_hash;
-    const { calls, addresses } = new import_starknet36.Deployer().buildDeployerCall({
+    const { calls, addresses } = new import_starknet37.Deployer().buildDeployerCall({
       classHash,
       constructorCalldata: constructorData
     }, acc.address);
@@ -48990,7 +50413,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
 }
 async function executeDeployCalls(contractsInfo, acc, provider2) {
   for (let contractInfo of contractsInfo) {
-    (0, import_assert.default)(import_starknet36.num.toHexString(contractInfo.call.contractAddress) == import_starknet36.num.toHexString(import_starknet36.constants.UDC.ADDRESS), "Must be pointed at UDC address");
+    (0, import_assert.default)(import_starknet37.num.toHexString(contractInfo.call.contractAddress) == import_starknet37.num.toHexString(import_starknet37.constants.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(", ")}`);
@@ -49014,7 +50437,7 @@ async function executeTransactions(calls, acc, provider2, remarks) {
   if (remarks)
     console.log(`Remarks: ${remarks}`);
   await provider2.waitForTransaction(tx.transaction_hash, {
-    successStates: [import_starknet36.TransactionExecutionStatus.SUCCEEDED]
+    successStates: [import_starknet37.TransactionExecutionStatus.SUCCEEDED]
   });
   console.log(`Transaction confirmed: ${tx.transaction_hash}`);
   return tx;
@@ -49025,10 +50448,10 @@ async function myWaitForTransaction(transaction_hash, provider2, retry = 0) {
   try {
     const status = await provider2.getTransactionStatus(transaction_hash);
     logger.verbose(`Transaction status: ${JSON.stringify(status.execution_status)}`);
-    if (status.execution_status == import_starknet36.TransactionExecutionStatus.SUCCEEDED) {
+    if (status.execution_status == import_starknet37.TransactionExecutionStatus.SUCCEEDED) {
       return true;
     }
-    if (status.execution_status == import_starknet36.TransactionExecutionStatus.REVERTED) {
+    if (status.execution_status == import_starknet37.TransactionExecutionStatus.REVERTED) {
       throw new Error(`Transaction reverted: ${transaction_hash}`);
     }
     if (retry > MAX_RETRIES2) {
@@ -49135,6 +50558,7 @@ var deployer_default = Deployer;
   SIMPLE_SANITIZER,
   SIMPLE_SANITIZER_V2,
   SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
+  SVK_SIMPLE_SANITIZER,
   SenseiStrategies,
   SenseiVault,
   SolveBudget,
@@ -49154,6 +50578,8 @@ var deployer_default = Deployer;
   TokenTransferAdapter,
   UNIVERSAL_ADAPTERS,
   UNIVERSAL_MANAGE_IDS,
+  USDCBoostedStrategies,
+  USDCBoostedStrategy,
   UniversalLstMultiplierStrategy,
   UniversalStrategies,
   UniversalStrategy,