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

package/dist/index.browser.global.js

@@ -3926,8 +3926,8 @@ var strkfarm_risk_engine = (() => {
         }
       }
       exports.output = output2;
-      var assert5 = { number: number2, bool, bytes: bytes2, hash: hash3, exists: exists2, output: output2 };
-      exports.default = assert5;
+      var assert6 = { number: number2, bool, bytes: bytes2, hash: hash3, exists: exists2, output: output2 };
+      exports.default = assert6;
     }
   });
 
@@ -12885,8 +12885,8 @@ ${r2}}` : "}", l2;
         }
       }
       exports.output = output2;
-      var assert5 = { number: number2, bool, bytes: bytes2, hash: hash3, exists: exists2, output: output2 };
-      exports.default = assert5;
+      var assert6 = { number: number2, bool, bytes: bytes2, hash: hash3, exists: exists2, output: output2 };
+      exports.default = assert6;
     }
   });
 
@@ -17772,7 +17772,7 @@ ${r2}}` : "}", l2;
         return BlockTag22;
       })(BlockTag2 || {});
       var import_starknet_types_07 = require_cjs();
-      function assert5(condition, message) {
+      function assert6(condition, message) {
         if (!condition) {
           throw new Error(message || "Assertion failure");
         }
@@ -17800,7 +17800,7 @@ ${r2}}` : "}", l2;
         toHexString: () => toHexString2,
         toStorageKey: () => toStorageKey2
       });
-      var import_utils163 = require_utils();
+      var import_utils164 = require_utils();
       function isHex3(hex) {
         return /^0x[0-9a-f]*$/i.test(hex);
       }
@@ -17828,7 +17828,7 @@ ${r2}}` : "}", l2;
         const inputBigInt = BigInt(input);
         const lowerBoundBigInt = BigInt(lowerBound);
         const upperBoundBigInt = BigInt(upperBound);
-        assert5(
+        assert6(
           inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
           `Message not signable, ${messageSuffix}.`
         );
@@ -17873,7 +17873,7 @@ ${r2}}` : "}", l2;
         if (adaptedValue.length % 2 !== 0) {
           adaptedValue = `0${adaptedValue}`;
         }
-        return (0, import_utils163.hexToBytes)(adaptedValue);
+        return (0, import_utils164.hexToBytes)(adaptedValue);
       }
       function addPercent2(number22, percent) {
         const bigIntNum = BigInt(number22);
@@ -17892,14 +17892,14 @@ ${r2}}` : "}", l2;
         keccakBn: () => keccakBn2,
         starknetKeccak: () => starknetKeccak2
       });
-      var import_starknet41 = require_lib2();
+      var import_starknet42 = require_lib2();
       function keccakBn2(value) {
         const hexWithoutPrefix = removeHexPrefix2(toHex3(BigInt(value)));
         const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-        return addHexPrefix2((0, import_starknet41.keccak)(hexToBytes5(addHexPrefix2(evenHex))).toString(16));
+        return addHexPrefix2((0, import_starknet42.keccak)(hexToBytes5(addHexPrefix2(evenHex))).toString(16));
       }
       function keccakHex2(str) {
-        return addHexPrefix2((0, import_starknet41.keccak)(utf8ToArray2(str)).toString(16));
+        return addHexPrefix2((0, import_starknet42.keccak)(utf8ToArray2(str)).toString(16));
       }
       function starknetKeccak2(str) {
         const hash3 = BigInt(keccakHex2(str));
@@ -19261,37 +19261,37 @@ ${r2}}` : "}", l2;
         }
       }
       var validateFelt2 = (parameter, input) => {
-        assert5(
+        assert6(
           isString3(parameter) || isNumber4(parameter) || isBigInt2(parameter),
           `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
         );
         if (isString3(parameter) && !isHex3(parameter))
           return;
         const param = BigInt(parameter.toString(10));
-        assert5(
+        assert6(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1266
           param >= 0n && param <= 2n ** 252n - 1n,
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
       };
       var validateBytes31 = (parameter, input) => {
-        assert5(isString3(parameter), `Validate: arg ${input.name} should be a string.`);
-        assert5(
+        assert6(isString3(parameter), `Validate: arg ${input.name} should be a string.`);
+        assert6(
           parameter.length < 32,
           `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`
         );
       };
       var validateByteArray = (parameter, input) => {
-        assert5(isString3(parameter), `Validate: arg ${input.name} should be a string.`);
+        assert6(isString3(parameter), `Validate: arg ${input.name} should be a string.`);
       };
       var validateUint2 = (parameter, input) => {
         if (isNumber4(parameter)) {
-          assert5(
+          assert6(
             parameter <= Number.MAX_SAFE_INTEGER,
             `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
           );
         }
-        assert5(
+        assert6(
           isString3(parameter) || isNumber4(parameter) || isBigInt2(parameter) || typeof parameter === "object" && "low" in parameter && "high" in parameter || typeof parameter === "object" && ["limb0", "limb1", "limb2", "limb3"].every((key) => key in parameter),
           `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt), but is ${typeof parameter} ${parameter}.`
         );
@@ -19308,60 +19308,60 @@ ${r2}}` : "}", l2;
         }
         switch (input.type) {
           case "core::integer::u8":
-            assert5(
+            assert6(
               param >= 0n && param <= 255n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
             );
             break;
           case "core::integer::u16":
-            assert5(
+            assert6(
               param >= 0n && param <= 65535n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
             );
             break;
           case "core::integer::u32":
-            assert5(
+            assert6(
               param >= 0n && param <= 4294967295n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
             );
             break;
           case "core::integer::u64":
-            assert5(
+            assert6(
               param >= 0n && param <= 2n ** 64n - 1n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
             );
             break;
           case "core::integer::u128":
-            assert5(
+            assert6(
               param >= 0n && param <= 2n ** 128n - 1n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
             );
             break;
           case "core::integer::u256":
-            assert5(
+            assert6(
               param >= 0n && param <= 2n ** 256n - 1n,
               `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
             );
             break;
           case "core::integer::u512":
-            assert5(CairoUint5122.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+            assert6(CairoUint5122.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
             break;
           case "core::starknet::class_hash::ClassHash":
-            assert5(
+            assert6(
               // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
               param >= 0n && param <= 2n ** 252n - 1n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
             );
             break;
           case "core::starknet::contract_address::ContractAddress":
-            assert5(
+            assert6(
               // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
               param >= 0n && param <= 2n ** 252n - 1n,
               `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
             );
             break;
           case "core::starknet::secp256k1::Secp256k1Point": {
-            assert5(
+            assert6(
               param >= 0n && param <= 2n ** 512n - 1n,
               `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`
             );
@@ -19372,7 +19372,7 @@ ${r2}}` : "}", l2;
         }
       };
       var validateBool2 = (parameter, input) => {
-        assert5(
+        assert6(
           isBoolean3(parameter),
           `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
         );
@@ -19383,31 +19383,31 @@ ${r2}}` : "}", l2;
           return;
         }
         if (input.type === "core::starknet::eth_address::EthAddress") {
-          assert5(
+          assert6(
             typeof parameter !== "object",
             `EthAddress type is waiting a BigNumberish. Got ${parameter}`
           );
           const param = BigInt(parameter.toString(10));
-          assert5(
+          assert6(
             // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1259
             param >= 0n && param <= 2n ** 160n - 1n,
             `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^160-1]`
           );
           return;
         }
-        assert5(
+        assert6(
           typeof parameter === "object" && !Array.isArray(parameter),
           `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
         );
         structs[input.type].members.forEach(({ name }) => {
-          assert5(
+          assert6(
             Object.keys(parameter).includes(name),
             `Validate: arg ${input.name} should have a property ${name}`
           );
         });
       };
       var validateEnum2 = (parameter, input) => {
-        assert5(
+        assert6(
           typeof parameter === "object" && !Array.isArray(parameter),
           `Validate: arg ${input.name} is cairo type Enum (${input.type}), and should be defined as js object (not array)`
         );
@@ -19427,7 +19427,7 @@ ${r2}}` : "}", l2;
         );
       };
       var validateTuple2 = (parameter, input) => {
-        assert5(
+        assert6(
           typeof parameter === "object" && !Array.isArray(parameter),
           `Validate: arg ${input.name} should be a tuple (defined as object)`
         );
@@ -19437,7 +19437,7 @@ ${r2}}` : "}", l2;
         if (isTypeFelt2(baseType) && isLongText2(parameter)) {
           return;
         }
-        assert5(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+        assert6(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
         switch (true) {
           case isTypeFelt2(baseType):
             parameter.forEach((param) => validateFelt2(param, input));
@@ -19472,14 +19472,14 @@ ${r2}}` : "}", l2;
       };
       var validateNonZero2 = (parameter, input) => {
         const baseType = getArrayType2(input.type);
-        assert5(
+        assert6(
           isTypeUint2(baseType) && baseType !== CairoUint5122.abiSelector || isTypeFelt2(baseType),
           `Validate: ${input.name} type is not authorized for NonZero type.`
         );
         switch (true) {
           case isTypeFelt2(baseType):
             validateFelt2(parameter, input);
-            assert5(
+            assert6(
               BigInt(parameter.toString(10)) > 0,
               "Validate: value 0 is not authorized in NonZero felt252 type."
             );
@@ -19488,13 +19488,13 @@ ${r2}}` : "}", l2;
             validateUint2(parameter, { name: "", type: baseType });
             switch (input.type) {
               case "core::integer::u256":
-                assert5(
+                assert6(
                   new CairoUint2562(parameter).toBigInt() > 0,
                   "Validate: value 0 is not authorized in NonZero uint256 type."
                 );
                 break;
               default:
-                assert5(
+                assert6(
                   toBigInt5(parameter) > 0,
                   "Validate: value 0 is not authorized in NonZero uint type."
                 );
@@ -19575,7 +19575,7 @@ ${r2}}` : "}", l2;
               const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
               return type === "INVOKE" ? !isView : isView;
             }).map((abi) => abi.name);
-            assert5(
+            assert6(
               invocableFunctionNames.includes(method),
               `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
             );
@@ -20272,7 +20272,7 @@ ${r2}}` : "}", l2;
         toTransactionVersion: () => toTransactionVersion2,
         v3Details: () => v3Details2
       });
-      var import_starknet42 = require_lib2();
+      var import_starknet43 = require_lib2();
       var import_pako2 = require_pako();
       function compressProgram2(jsonProgram) {
         const stringified = isString3(jsonProgram) ? jsonProgram : stringify22(jsonProgram);
@@ -20286,8 +20286,8 @@ ${r2}}` : "}", l2;
         return parse22(decompressed);
       }
       function randomAddress2() {
-        const randomKeyPair = import_starknet42.utils.randomPrivateKey();
-        return (0, import_starknet42.getStarkKey)(randomKeyPair);
+        const randomKeyPair = import_starknet43.utils.randomPrivateKey();
+        return (0, import_starknet43.getStarkKey)(randomKeyPair);
       }
       function makeAddress(input) {
         return addHexPrefix2(input).toLowerCase();
@@ -20419,7 +20419,7 @@ ${r2}}` : "}", l2;
       function validateAndParseEthAddress2(address) {
         assertInRange2(address, ZERO2, 2n ** 160n - 1n, "Ethereum Address ");
         const result2 = addHexPrefix2(removeHexPrefix2(toHex3(address)).padStart(40, "0"));
-        assert5(Boolean(result2.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
+        assert6(Boolean(result2.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
         return result2;
       }
       var import_fetch_cookie = __toESM2(require_cjs2());
@@ -21978,7 +21978,7 @@ ${r2}}` : "}", l2;
         }
         async getL1MessageHash(l2TxHash) {
           const transaction2 = await this.channel.getTransactionByHash(l2TxHash);
-          assert5(transaction2.type === "L1_HANDLER", "This L2 transaction is not a L1 message.");
+          assert6(transaction2.type === "L1_HANDLER", "This L2 transaction is not a L1 message.");
           const { calldata, contract_address, entry_point_selector, nonce } = transaction2;
           const params = [
             calldata[0],
@@ -22773,7 +22773,7 @@ ${r2}}` : "}", l2;
       };
       function assertRange2(data, type, { min, max }) {
         const value = BigInt(data);
-        assert5(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+        assert6(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
       }
       function identifyRevision2({ types: types2, domain }) {
         if (revisionConfiguration2[import_starknet_types_07.TypedDataRevision.ACTIVE].domain in types2 && domain.revision === import_starknet_types_07.TypedDataRevision.ACTIVE)
@@ -22968,7 +22968,7 @@ ${r2}}` : "}", l2;
           }
           case "bool": {
             if (revision === import_starknet_types_07.TypedDataRevision.ACTIVE) {
-              assert5(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
+              assert6(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
             }
             return [type, getHex2(data)];
           }
@@ -23337,7 +23337,7 @@ ${r2}}` : "}", l2;
           }
           while (!abiEvent.name) {
             const hashName = recEvent.keys.shift();
-            assert5(!!hashName, 'Not enough data in "key" property of this event.');
+            assert6(!!hashName, 'Not enough data in "key" property of this event.');
             abiEvent = abiEvent[hashName];
           }
           const parsedEvent = {};
@@ -24349,7 +24349,7 @@ ${r2}}` : "}", l2;
           formatResponse = void 0,
           blockIdentifier = void 0
         } = {}) {
-          assert5(this.address !== null, "contract is not connected to an address");
+          assert6(this.address !== null, "contract is not connected to an address");
           const calldata = getCalldata(args, () => {
             if (parseRequest) {
               this.callData.validate("CALL", method, args);
@@ -24376,7 +24376,7 @@ ${r2}}` : "}", l2;
           });
         }
         invoke(method, args = [], { parseRequest = true, maxFee, nonce, signature } = {}) {
-          assert5(this.address !== null, "contract is not connected to an address");
+          assert6(this.address !== null, "contract is not connected to an address");
           const calldata = getCalldata(args, () => {
             if (parseRequest) {
               this.callData.validate("INVOKE", method, args);
@@ -24410,7 +24410,7 @@ ${r2}}` : "}", l2;
           );
         }
         async estimate(method, args = []) {
-          assert5(this.address !== null, "contract is not connected to an address");
+          assert6(this.address !== null, "contract is not connected to an address");
           if (!getCalldata(args, () => false)) {
             this.callData.validate("INVOKE", method, args);
           }
@@ -24508,7 +24508,7 @@ ${r2}}` : "}", l2;
             constructorCalldata,
             salt: options.addressSalt
           });
-          assert5(Boolean(contract_address), "Deployment of the contract failed");
+          assert6(Boolean(contract_address), "Deployment of the contract failed");
           const contractInstance = new Contract3(
             this.compiledContract.abi,
             contract_address,
@@ -28729,6 +28729,7 @@ ${r2}}` : "}", l2;
     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,
@@ -28745,6 +28746,8 @@ ${r2}}` : "}", l2;
     TokenTransferAdapter: () => TokenTransferAdapter,
     UNIVERSAL_ADAPTERS: () => UNIVERSAL_ADAPTERS,
     UNIVERSAL_MANAGE_IDS: () => UNIVERSAL_MANAGE_IDS,
+    USDCBoostedStrategies: () => USDCBoostedStrategies,
+    USDCBoostedStrategy: () => USDCBoostedStrategy,
     UniversalLstMultiplierStrategy: () => UniversalLstMultiplierStrategy,
     UniversalStrategies: () => UniversalStrategies,
     UniversalStrategy: () => UniversalStrategy,
@@ -109341,6 +109344,7 @@ spurious results.`);
 
   // 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");
@@ -123194,7 +123198,14 @@ spurious results.`);
       }
       const normalizedDebtAmount = this._normalizeDebtAmountFromHelper(
         helperOutput
-      );
+      ).minus(state.currentDebt);
+      if (normalizedDebtAmount.lessThan(0)) {
+        logger2.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)
@@ -123212,8 +123223,8 @@ spurious results.`);
         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
@@ -123410,6 +123421,24 @@ spurious results.`);
       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 defaults2 = await this._buildDefaultDepositDeltas({ amount: depositAmount });
+      return defaults2.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 defaults2 = await this._buildDefaultWithdrawDeltas({ amount: withdrawAmount });
+      return defaults2.debt.amount;
+    }
   };
 
   // src/strategies/universal-adapters/extended-adapter.ts
@@ -123469,6 +123498,25 @@ spurious results.`);
         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") {
+          logger2.error("error getting funding payments", response.data);
+          return { success: false, data: [] };
+        }
+        return { success: true, data: response.data ?? [] };
+      } catch (err2) {
+        logger2.error("error getting funding payments", err2);
+        return { success: false, data: [] };
+      }
+    }
     async getPosition(supportedPosition) {
       const holdings = await this.getExtendedDepositAmount();
       if (!holdings) {
@@ -126102,6 +126150,760 @@ spurious results.`);
     }
   ];
 
+  // 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) {
@@ -126215,6 +127017,100 @@ spurious results.`);
         throw error2;
       }
     }
+    async getPendingAssetsFromOwner(owner = this._positionOwner(), decimals = this.config.baseToken.decimals) {
+      const vault = new 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) {
+        logger2.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 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) {
+          logger2.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 = uint256_exports.bnToUint256(currentId);
+            const ownerRaw = await nftContract.owner_of(idU256);
+            const nftOwnerAddr = ContractAddr.from(ownerRaw.toString());
+            if (nftOwnerAddr.eq(owner)) {
+              matchingIds.push(currentId);
+              logger2.debug(
+                `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found matching NFT ID ${currentId} for owner ${owner.address}`
+              );
+            }
+            currentId--;
+          } catch (e) {
+            logger2.info(
+              `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Reached last pending NFT at id ${currentId}`
+            );
+            break;
+          }
+        }
+        if (matchingIds.length === 0) {
+          logger2.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 = uint256_exports.bnToUint256(nftId);
+            const infoRaw = await nftContract.id_to_info(idU256);
+            const nominal = BigInt(infoRaw.nominal.toString());
+            totalNominal += nominal;
+            logger2.debug(
+              `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: NFT ID ${nftId} has nominal ${nominal}`
+            );
+          } catch (e) {
+            logger2.warn(
+              `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Failed to get info for NFT ID ${nftId}: ${e.message}`
+            );
+          }
+        }
+        logger2.info(
+          `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: Found ${matchingIds.length} NFTs with total nominal ${totalNominal}`
+        );
+        return Web3Number.fromWei(totalNominal.toString(), decimals);
+      } catch (error2) {
+        logger2.error(
+          `${_SvkTrovesAdapter.name}::getPendingAssetsFromOwnerNFTMethod: ${error2.message}`
+        );
+        return Web3Number.fromWei("0", decimals);
+      }
+    }
     async maxDeposit(amount) {
       const baseToken = this.config.baseToken;
       if (!amount) {
@@ -126279,9 +127175,9 @@ spurious results.`);
       return [
         {
           target: strategyVault,
-          method: "withdraw",
+          method: "request_redeem",
           packedArguments: [recv.toBigInt(), owner.toBigInt()],
-          sanitizer: SIMPLE_SANITIZER,
+          sanitizer: SVK_SIMPLE_SANITIZER,
           id: this._withdrawCallProofReadableId()
         }
       ];
@@ -126343,16 +127239,23 @@ spurious results.`);
       const uint256Amount = uint256_exports.bnToUint256(amount.toWei());
       const recv = this.config.vaultAllocator;
       const owner = this.config.vaultAllocator;
+      const vault = new Contract({
+        abi: universal_vault_abi_default,
+        address: strategyVault.address,
+        providerOrAccount: this.config.networkConfig.provider
+      });
+      const sharesRaw = await vault.convert_to_shares(uint256Amount);
+      const sharesU256 = uint256_exports.bnToUint256(sharesRaw.toString());
       return [
         {
           proofReadableId: this._withdrawCallProofReadableId(),
-          sanitizer: SIMPLE_SANITIZER,
+          sanitizer: SVK_SIMPLE_SANITIZER,
           call: {
             contractAddress: strategyVault,
-            selector: hash_exports.getSelectorFromName("withdraw"),
+            selector: hash_exports.getSelectorFromName("request_redeem"),
             calldata: [
-              toBigInt3(uint256Amount.low.toString()),
-              toBigInt3(uint256Amount.high.toString()),
+              toBigInt3(sharesU256.low.toString()),
+              toBigInt3(sharesU256.high.toString()),
               recv.toBigInt(),
               owner.toBigInt()
             ]
@@ -128133,9 +129036,9 @@ spurious results.`);
       * Builds a manage call from an adapter's proof tree.
       * DRY helper for the repeated getProofs → getManageCall pattern.
       */
-    async buildManageCallFromAdapter(adapter2, isDeposit, amount) {
+    async buildManageCallFromAdapter(adapter2, isDeposit, amount, additionalParams) {
       const proofsInfo = adapter2.getProofs(isDeposit, this.getMerkleTree());
-      const manageCalls = await proofsInfo.callConstructor({ amount });
+      const manageCalls = await proofsInfo.callConstructor({ amount, ...additionalParams });
       return this.getManageCall(
         this.getProofGroupsForManageCalls(manageCalls),
         manageCalls
@@ -129324,6 +130227,525 @@ spurious results.`);
     getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
   ];
 
+  // src/strategies/usdc-boosted-strategy.tsx
+  var USDCBoostedStrategy = class _USDCBoostedStrategy extends SVKStrategy {
+    constructor(config3, pricer, metadata) {
+      super(config3, pricer, metadata);
+      this.metadata.additionalInfo.adapters.forEach((adapter2) => {
+        adapter2.adapter.config.networkConfig = this.config;
+        adapter2.adapter.config.pricer = this.pricer;
+        if (adapter2.adapter._vesuAdapter) {
+          adapter2.adapter._vesuAdapter.networkConfig = this.config;
+          adapter2.adapter._vesuAdapter.pricer = this.pricer;
+        }
+      });
+    }
+    getTag() {
+      return `${_USDCBoostedStrategy.name}:${this.metadata.name}`;
+    }
+    getAdapterById(id2) {
+      const entry = this.metadata.additionalInfo.adapters.find(
+        (a) => a.id === id2
+      );
+      if (!entry) {
+        throw new Error(
+          `${this.getTag()}::getAdapterById: adapter not found for id "${id2}"`
+        );
+      }
+      return entry.adapter;
+    }
+    async getVesuModifyPositionCall(params) {
+      logger2.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) {
+      logger2.verbose(
+        `${this.getTag()}::getModifyHyperPositionCall isDeposit=${params.isDeposit}, amount=${params.amount}`
+      );
+      return this.buildManageCallFromAdapter(
+        this.getAdapterById("hyper_xstrk"),
+        params.isDeposit,
+        params.amount
+      );
+    }
+    async getAvnuSwapCall(params) {
+      logger2.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",
+        [uint256_exports.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 adapter2 of this.metadata.additionalInfo.adapters) {
+        const positions = await adapter2.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();
+      logger2.verbose(
+        `${this.getTag()} unused balance: ${unusedBalance.amount.toNumber()}`
+      );
+      netAUM = netAUM.plus(unusedBalance.amount);
+      const prevAum = await this.getPrevAUM();
+      logger2.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) {
+      logger2.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();
+        logger2.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(
+            (adapter2) => adapter2.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(
+          (adapter2) => adapter2.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(settings2) {
+    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: settings2.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(settings2),
+      // 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(settings2),
+      // 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 f2 = 10 ** precision;