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

package/src/strategies/universal-adapters/adapter-utils.ts

@@ -2,6 +2,8 @@ import { ContractAddr } from "@/dataTypes";
 
 // Zellic audited
 export const SIMPLE_SANITIZER = ContractAddr.from('0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4');
+// Above SIMPLE_SANITIZER was not exposing the request_redeem method
+export const SVK_SIMPLE_SANITIZER = ContractAddr.from('0x03dcde04343257c3ce14574676cb9c5b2eda16e332c1b8caf5dc4c95ac568d2f')
 export const EXTENDED_SANITIZER = ContractAddr.from('0x65891708362b24dcf4c40c8e218cce6e82d1d6b3a3404c9ab00a48f08e2c110');
 export const AVNU_LEGACY_SANITIZER = ContractAddr.from('0x0656fBE853f116DD53956176a553eDe8fE65632252f8aceB50C1B9B6c8237309');
 // Without flashloan options

package/src/strategies/universal-adapters/avnu-adapter.ts

@@ -7,7 +7,6 @@ import {
 } from "./baseAdapter";
 import { toBigInt } from "./adapter-utils";
 import { Protocols } from "@/interfaces";
-import { MAX_DELAY } from "../vesu-extended-strategy/utils/constants";
 import { SupportedPosition } from "./baseAdapter";
 import { PositionAPY, APYType, PositionAmount } from "./baseAdapter";
 import { Web3Number } from "@/dataTypes";
@@ -15,17 +14,25 @@ import { PositionInfo } from "./baseAdapter";
 import { ManageCall } from "./baseAdapter";
 import { ContractAddr } from "@/dataTypes";
 import { AVNU_EXCHANGE } from "./adapter-utils";
-import { MAX_RETRIES } from "../vesu-extended-strategy/utils/constants";
 import { Quote } from "@avnu/avnu-sdk";
 import { hash, uint256 } from "starknet";
 import { AvnuWrapper } from "@/modules/avnu";
 import axios from "axios";
 import { SIMPLE_SANITIZER } from "./adapter-utils";
-import { returnFormattedAmount } from "../vesu-extended-strategy/utils/helper";
 import { assert, logger } from "@/utils";
 import { Global } from "@/global";
 import { TokenInfo } from "@/interfaces";
 import { ERC20 } from "@/modules";
+import { MAX_AVNU_RETRY_DELAY } from "../constants";
+
+export interface AvnuDepositParams extends DepositParams {
+  minAmount?: Web3Number;
+}
+
+export interface AvnuWithdrawParams extends WithdrawParams {
+  minAmount?: Web3Number;
+}
+
 export interface AvnuAdapterConfig extends BaseAdapterConfig {
   baseUrl: string;
   avnuContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
@@ -34,7 +41,7 @@ export interface AvnuAdapterConfig extends BaseAdapterConfig {
   maximumExtendedPriceDifferenceForSwapClosing: number;
 }
 
-export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+export class AvnuAdapter extends BaseAdapter<AvnuDepositParams, AvnuWithdrawParams> {
   readonly config: AvnuAdapterConfig;
   protected avnuWrapper: AvnuWrapper;
   lastSwapPriceInfo: SwapPriceInfo | null = null;
@@ -91,9 +98,10 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   private async buildSwapCalls(
-    params: DepositParams | WithdrawParams,
+    params: AvnuDepositParams | AvnuWithdrawParams,
     fromToken: TokenInfo,
     toToken: TokenInfo,
+    // NOTE : this is a direction flag that we are swapping in this direction
     usdcToBtc: boolean,
   ): Promise<ManageCall[]> {
     const vaultAllocator = ContractAddr.from(this.config.vaultAllocator.address);
@@ -121,13 +129,14 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     };
     logger.verbose(
       `${AvnuAdapter.name}::buildSwapCalls stored price info: ` +
-        `${fromAmt} ${fromToken.symbol} → ${toAmt} ${toToken.symbol}, ` +
-        `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`,
+      `${fromAmt} ${fromToken.symbol} → ${toAmt} ${toToken.symbol}, ` +
+      `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`,
     );
 
     const getCalldata = await this.avnuWrapper.getSwapCallData(
       quote,
       vaultAllocator.address,
+      params.minAmount,
     );
     const swapCallData = getCalldata[0];
     const approveAmount = uint256.bnToUint256(params.amount.toWei());
@@ -259,7 +268,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     return [];
   }
 
-  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+  async getDepositCall(params: AvnuDepositParams): Promise<ManageCall[]> {
     try {
       const fromToken = this.config.supportedPositions[0].asset; //usdc
       const toToken = this.config.supportedPositions[1].asset; //wbtc
@@ -277,7 +286,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   //Swap wbtc to usdc
-  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+  async getWithdrawCall(params: AvnuWithdrawParams): Promise<ManageCall[]> {
     try {
       const toToken = this.config.supportedPositions[0].asset;
       const fromToken = this.config.supportedPositions[1].asset;
@@ -321,7 +330,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
         if (attempt === retries - 1) {
           throw err;
         }
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+        await new Promise((resolve) => setTimeout(resolve, MAX_AVNU_RETRY_DELAY));
       }
     }
     throw new Error("Failed to fetch quote after retries");

package/src/strategies/universal-adapters/index.ts

@@ -4,8 +4,7 @@ export * from "./vesu-adapter";
 export * from "./vesu-supply-only-adapter";
 export * from "./vesu-multiply-adapter";
 export * from "./vesu-modify-position-adapter";
-export * from "./extended-adapter";
 export * from "./adapter-utils";
 export * from "./token-transfer-adapter";
 export * from "./avnu-adapter";
-export * from "./svk-troves-adapter";
+export * from "./svk-troves-adapter";

package/src/strategies/universal-adapters/svk-troves-adapter.ts

@@ -14,11 +14,12 @@ import {
   WithdrawParams,
   PositionAmount,
 } from "./baseAdapter";
-import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { SIMPLE_SANITIZER, SVK_SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
 import { hash, uint256, Contract } from "starknet";
 import { logger } from "@/utils";
 // Troves SVK universal vault ABI: ERC-4626 + SVK views (e.g. due_assets_from_owner).
 import universalVaultAbi from "@/data/universal-vault.abi.json";
+import redeemRequestNftAbi from "@/data/redeem-request-nft.abi.json";
 
 /** Public Troves strategies feed (APY + metadata). Override in config for tests. */
 export const DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
@@ -40,6 +41,11 @@ export interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
   positionOwner?: ContractAddr;
   /** Optional APY endpoint (defaults to {@link DEFAULT_TROVES_STRATEGIES_API}). */
   trovesStrategiesApiUrl?: string;
+  /**
+   * Optional redeem request NFT contract address. When provided, pending assets are calculated
+   * using `getPendingAssetsFromOwnerNFTMethod` instead of `due_assets_from_owner`.
+   */
+  redeemRequestNFT?: ContractAddr;
 }
 
 type TrovesStrategiesApiPayload = {
@@ -164,13 +170,21 @@ export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams>
       const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
 
       let pending = Web3Number.fromWei("0", decimals);
-      try {
-        const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
-        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
-      } catch (e) {
-        logger.warn(
-          `${SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+      if (this.config.redeemRequestNFT) {
+        pending = await this.getPendingAssetsFromOwnerNFTMethod(
+          this.config.redeemRequestNFT,
+          owner,
+          decimals,
         );
+      } else {
+        try {
+          const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
+          pending = Web3Number.fromWei(dueRaw.toString(), decimals);
+        } catch (e) {
+          logger.warn(
+            `${SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+          );
+        }
       }
 
       const total = liquid.plus(pending);
@@ -189,6 +203,131 @@ export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams>
     }
   }
 
+  async getPendingAssetsFromOwner(
+    owner: ContractAddr = this._positionOwner(),
+    decimals: number = this.config.baseToken.decimals,
+  ): Promise<Web3Number> {
+    const vault = new Contract({
+      abi: universalVaultAbi as never,
+      address: this.config.strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider,
+    });
+
+    try {
+      const dueRaw: any = 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 as Error).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: ContractAddr,
+    owner: ContractAddr = this._positionOwner(),
+    decimals: number = this.config.baseToken.decimals,
+  ): Promise<Web3Number> {
+    try {
+      const nftContract = new Contract({
+        abi: redeemRequestNftAbi as never,
+        address: redeemRequestNFT.address,
+        providerOrAccount: this.config.networkConfig.provider,
+      });
+
+      // Step 1: Get the latest NFT ID (the one that is not yet used)
+      const idLenRaw: any = 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);
+      }
+
+      // Step 2: Start from (latestId - 1) and loop backwards to find all pending NFTs
+      const matchingIds: bigint[] = [];
+      let currentId = latestId - 1n;
+
+      while (currentId >= 0n) {
+        try {
+          // Convert currentId to u256 format
+          const idU256 = uint256.bnToUint256(currentId);
+          const ownerRaw: any = await nftContract.owner_of(idU256);
+
+          // Step 3: Filter IDs that have the owner matching our parameter
+          // Use ContractAddr.from to normalize addresses before comparison
+          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) {
+          // When owner_of throws an error, it means we've reached the last pending NFT
+          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);
+      }
+
+      // Step 4: For each matching ID, call id_to_info and sum up all nominal values
+      let totalNominal = 0n;
+
+      for (const nftId of matchingIds) {
+        try {
+          const idU256 = uint256.bnToUint256(nftId);
+          const infoRaw: any = await nftContract.id_to_info(idU256);
+
+          // The response is a struct with { epoch: u256, nominal: u256 }
+          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 as Error).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 as Error).message}`,
+      );
+      return Web3Number.fromWei("0", decimals);
+    }
+  }
+
   async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
     const baseToken = this.config.baseToken;
     if (!amount) {
@@ -270,9 +409,9 @@ export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams>
     return [
       {
         target: strategyVault,
-        method: "withdraw",
+        method: "request_redeem",
         packedArguments: [recv.toBigInt(), owner.toBigInt()],
-        sanitizer: SIMPLE_SANITIZER,
+        sanitizer: SVK_SIMPLE_SANITIZER,
         id: this._withdrawCallProofReadableId(),
       },
     ];
@@ -340,16 +479,24 @@ export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams>
     const recv = this.config.vaultAllocator;
     const owner = this.config.vaultAllocator;
 
+    const vault = new Contract({
+      abi: universalVaultAbi as never,
+      address: strategyVault.address,
+      providerOrAccount: this.config.networkConfig.provider,
+    });
+    const sharesRaw: any = await vault.convert_to_shares(uint256Amount);
+    const sharesU256 = uint256.bnToUint256(sharesRaw.toString());
+
     return [
       {
         proofReadableId: this._withdrawCallProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
+        sanitizer: SVK_SIMPLE_SANITIZER,
         call: {
           contractAddress: strategyVault,
-          selector: hash.getSelectorFromName("withdraw"),
+          selector: 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(),
           ],

package/src/strategies/universal-adapters/vesu-modify-position-adapter.ts

@@ -1,6 +1,7 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IProtocol, Protocols, TokenInfo } from "@/interfaces";
 import {
+  APYType,
   BaseAdapter,
   BaseAdapterConfig,
   ManageCall,
@@ -86,7 +87,10 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
 
   private _getTargetHealthFactor(): number {
     if (this.config.targetLtv <= 0) {
-      return 1.0;
+      throw new Error(`Target LTV is less than or equal to 0: ${this.config.targetLtv}`);
+    }
+    if (this.config.targetLtv >= this._getEffectiveMaxLtv(this.config.maxLtv)) {
+      throw new Error(`Target LTV is greater than or equal to max LTV: ${this.config.targetLtv} >= ${this._getEffectiveMaxLtv(this.config.maxLtv)}`);
     }
     return this.config.maxLtv / this.config.targetLtv;
   }
@@ -198,9 +202,19 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
     if (!helperOutput || helperOutput.lessThan(0)) {
       throw new Error(`Failed to calculate default deposit debt delta: ${helperOutput?.toNumber()}`);
     }
+    // Fixed :
+    // getMaxDebtAmount returns the TOTAL target debt at the new collateral level.
+    // Subtract current debt to get the incremental borrow delta.
     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),
@@ -221,8 +235,8 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
       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,
@@ -262,21 +276,21 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
     const call = contract.populate("modify_position", {
       params: isV2
         ? {
-            collateral_asset: this.config.collateral.address.toBigInt(),
-            debt_asset: this.config.debt.address.toBigInt(),
-            user: this.config.vaultAllocator.toBigInt(),
-            collateral: this._amountStruct(collateralDelta),
-            debt: this._amountStruct(debtDelta),
-          }
+          collateral_asset: this.config.collateral.address.toBigInt(),
+          debt_asset: this.config.debt.address.toBigInt(),
+          user: this.config.vaultAllocator.toBigInt(),
+          collateral: this._amountStruct(collateralDelta),
+          debt: this._amountStruct(debtDelta),
+        }
         : {
-            pool_id: this.config.poolId.toBigInt(),
-            collateral_asset: this.config.collateral.address.toBigInt(),
-            debt_asset: this.config.debt.address.toBigInt(),
-            user: this.config.vaultAllocator.toBigInt(),
-            collateral: this._amountStruct(collateralDelta),
-            debt: this._amountStruct(debtDelta),
-            data: [0],
-          },
+          pool_id: this.config.poolId.toBigInt(),
+          collateral_asset: this.config.collateral.address.toBigInt(),
+          debt_asset: this.config.debt.address.toBigInt(),
+          user: this.config.vaultAllocator.toBigInt(),
+          collateral: this._amountStruct(collateralDelta),
+          debt: this._amountStruct(debtDelta),
+          data: [0],
+        },
     });
     return {
       proofReadableId,
@@ -320,11 +334,26 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
   }
 
   async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
-    return getVesuCommonMaxDeposit(this._getPositionCommonContext(), amount);
+    const { collateralPosition, debtPosition: debtPosition } = await getVesuCommonMaxDeposit(this._getPositionCommonContext(), amount);
+    // since this is not multiply adapter, max allow collateral is directly max allowed deposit
+    const netAPY =
+    (collateralPosition.apy.apy * collateralPosition.usdValue - debtPosition.apy.apy * debtPosition.usdValue) /
+    (collateralPosition.usdValue - debtPosition.usdValue);
+    return {
+      ...collateralPosition,
+      apy: { apy: netAPY, type: APYType.BASE },
+    };
   }
 
   async maxWithdraw(): Promise<PositionInfo> {
-    return getVesuCommonMaxWithdraw(this._getPositionCommonContext());
+    const { collateralPosition, debtPosition } = await getVesuCommonMaxWithdraw(this._getPositionCommonContext());
+    const netAPY =
+    (collateralPosition.apy.apy * collateralPosition.usdValue - debtPosition.apy.apy * debtPosition.usdValue) /
+    (collateralPosition.usdValue - debtPosition.usdValue);
+    return {
+      ...collateralPosition,
+      apy: { apy: netAPY, type: APYType.BASE },
+    };
   }
 
   protected _getDepositLeaf(): {
@@ -337,18 +366,18 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
     const { addr, isV2 } = getVesuSingletonAddress(this.config.poolId);
     const modifyPackedArguments = isV2
       ? [
-          this.config.collateral.address.toBigInt(),
-          this.config.debt.address.toBigInt(),
-          this.config.vaultAllocator.toBigInt(),
-        ]
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+      ]
       : [
-          this.config.poolId.toBigInt(),
-          this.config.collateral.address.toBigInt(),
-          this.config.debt.address.toBigInt(),
-          this.config.vaultAllocator.toBigInt(),
-          1n,
-          0n,
-        ];
+        this.config.poolId.toBigInt(),
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+        1n,
+        0n,
+      ];
 
     return [
       {
@@ -378,18 +407,18 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
     const { addr, isV2 } = getVesuSingletonAddress(this.config.poolId);
     const modifyPackedArguments = isV2
       ? [
-          this.config.collateral.address.toBigInt(),
-          this.config.debt.address.toBigInt(),
-          this.config.vaultAllocator.toBigInt(),
-        ]
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+      ]
       : [
-          this.config.poolId.toBigInt(),
-          this.config.collateral.address.toBigInt(),
-          this.config.debt.address.toBigInt(),
-          this.config.vaultAllocator.toBigInt(),
-          1n,
-          0n,
-        ];
+        this.config.poolId.toBigInt(),
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+        1n,
+        0n,
+      ];
 
     return [
       {
@@ -473,4 +502,24 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
     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: Web3Number): Promise<Web3Number> {
+    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: Web3Number): Promise<Web3Number> {
+    const defaults = await this._buildDefaultWithdrawDeltas({ amount: withdrawAmount });
+    return defaults.debt.amount;
+  }
 }