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

package/src/strategies/index.ts

@@ -6,6 +6,7 @@ export * from './sensei';
 export * from './universal-adapters';
 export * from './universal-strategy';
 export * from './universal-lst-muliplier-strategy';
+export * from './usdc-boosted-strategy';
 export * from './vesu-extended-strategy/vesu-extended-strategy';
 export * from './vesu-extended-strategy/utils/config.runtime';
 export * from './vesu-extended-strategy/utils/helper';

package/src/strategies/svk-strategy.ts

@@ -121,9 +121,10 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     adapter: { getProofs: (isDeposit: boolean, tree: any) => any },
     isDeposit: boolean,
     amount: Web3Number,
+    additionalParams?: Record<string, any>,
   ): Promise<Call> {
     const proofsInfo = adapter.getProofs(isDeposit, this.getMerkleTree());
-    const manageCalls = await proofsInfo.callConstructor({ amount });
+    const manageCalls = await proofsInfo.callConstructor({ amount, ...additionalParams });
     return this.getManageCall(
       this.getProofGroupsForManageCalls(manageCalls),
       manageCalls,
@@ -293,7 +294,7 @@ export abstract class SVKStrategy<S extends UniversalStrategySettings>
     const netAPY = weightedAPYs / totalHoldingsUSDValue;
     return {
       net: netAPY,
-      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+      splits: allPositions.map(p => ({ apy: p.apy.apy, id: p.remarks ?? '' }))
     };
   }
 

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

@@ -94,6 +94,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     params: DepositParams | WithdrawParams,
     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,8 +122,8 @@ 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(

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

@@ -24,6 +24,7 @@ import {
 import ExtendedWrapper, {
   AssetOperationStatus,
   AssetOperationType,
+  FundingPayment,
   FundingRate,
   OrderSide,
   Position,
@@ -127,6 +128,30 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
+  /** Account funding payment history via `GET /api/v1/account/funding-payments` (USDC amounts). */
+  public async getFundingPayments(
+    side: string,
+    startTime?: number,
+    limit?: number,
+  ): Promise<{ success: boolean; data: FundingPayment[] }> {
+    try {
+      const response = await this.client.getUserFundingPayments(
+        this.config.extendedMarketName,
+        side,
+        startTime ?? Date.now() - 30 * 24 * 60 * 60 * 1000,
+        limit ?? 200,
+      );
+      if (response.status !== "OK") {
+        logger.error("error getting funding payments", response.data);
+        return { success: false, data: [] };
+      }
+      return { success: true, data: response.data ?? [] };
+    } catch (err) {
+      logger.error("error getting funding payments", err);
+      return { success: false, data: [] };
+    }
+  }
+
   protected async getPosition(
     supportedPosition: SupportedPosition,
   ): Promise<PositionAmount> {

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";
@@ -189,6 +190,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 +396,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 +466,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

@@ -198,9 +198,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 +231,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 +272,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,
@@ -337,18 +347,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 +388,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 +483,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;
+  }
 }