@strkfarm/sdk 2.0.0-dev.28 → 2.0.0-dev.29

package/src/strategies/universal-adapters/vesu-multiply-adapter.ts

@@ -26,7 +26,7 @@ import {
   IncreaseLeverParams,
   DecreaseLeverParams,
 } from "./vesu-adapter";
-import { logger } from "@/utils";
+import { assert, logger } from "@/utils";
 import VesuMultiplyAbi from "@/data/vesu-multiple.abi.json";
 import { EkuboQuote, EkuboQuoter, TokenMarketData } from "@/modules";
 import { calculateDebtReductionAmountForWithdrawal } from "../vesu-extended-strategy/utils/helper";
@@ -586,6 +586,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const collateralToken = this.config.collateral;
     const debtToken = this.config.debt;
     const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
 
     const {
       existingCollateralInfo,
@@ -628,11 +629,20 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     let marginSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
     let addedCollateral: Web3Number = params.amount;
     let approveAmount: Web3Number = params.amount;
+    let aggregatedFromAmount = 0; // e.g. USDC
+    let aggregatedToAmount = 0; // e.g. BTC
+    let aggregatedFromSymbol: string = debtToken.symbol;
+    const aggregatedToSymbol = collateralToken.symbol;
+    let executedSwapCount = 0;
 
     if (params.marginSwap) {
       const marginToken = params.marginSwap.marginToken;
       const requiredAmount = params.amount;
 
+      // bcz, last swap price is configured to be common between margin swap and lever swap,
+      // hence need same tokens in both
+      assert(marginToken.address.eq(debtToken.address), 'Margin token must be the same as debt token');
+
       const marginSwapQuote = await ekuboQuoter.getQuoteExactOutput(
         marginToken.address.address,
         collateralToken.address.address,
@@ -649,6 +659,14 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         marginToken,
         collateralToken
       );
+      const marginSwapInputAmount = Web3Number
+        .fromWei(marginSwapQuote.total_calculated, marginToken.decimals)
+        .abs()
+        .toNumber();
+      const marginSwapOutputAmount = requiredAmount.abs().toNumber();
+      aggregatedFromAmount += marginSwapInputAmount;
+      aggregatedToAmount += marginSwapOutputAmount;
+      executedSwapCount += 1;
 
       approveAmount = Web3Number
         .fromWei(marginSwapQuote.total_calculated, marginToken.decimals)
@@ -680,13 +698,6 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     if (!debtAmount.isZero() && debtAmount.greaterThan(0)) {
       try {
         let swapQuote: EkuboQuote;
-        const debtAmountInCollateralUnits = new Web3Number(
-          debtAmount
-            .multipliedBy(debtPrice)
-            .dividedBy(collateralPrice)
-            .toFixed(6),
-          collateralToken.decimals
-        );
         if (params.leverSwap?.exactOutput) {
           swapQuote = await ekuboQuoter.getQuoteExactOutput(
             debtToken.address.address,
@@ -715,19 +726,9 @@ export class VesuMultiplyAdapter extends BaseAdapter<
 
           const inputAmt = debtAmount.abs().toNumber();
           const outputAmt = quoteOutputAmount;
-          this.lastSwapPriceInfo = {
-            source: "ekubo",
-            fromTokenSymbol: debtToken.symbol,
-            toTokenSymbol: collateralToken.symbol,
-            fromAmount: inputAmt,
-            toAmount: outputAmt,
-            effectivePrice: outputAmt !== 0 ? inputAmt / outputAmt : 0,
-          };
-          logger.verbose(
-            `${VesuMultiplyAdapter.name}::_getIncreaseCalldata stored price info: ` +
-            `${inputAmt} ${debtToken.symbol} → ${outputAmt} ${collateralToken.symbol}, ` +
-            `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`
-          );
+          aggregatedFromAmount += inputAmt;
+          aggregatedToAmount += outputAmt;
+          executedSwapCount += 1;
 
           leverSwap = ekuboQuoter.getVesuMultiplyQuote(
             swapQuote,
@@ -747,6 +748,22 @@ export class VesuMultiplyAdapter extends BaseAdapter<
       }
     }
 
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: aggregatedFromSymbol ?? debtToken.symbol,
+        toTokenSymbol: aggregatedToSymbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedToAmount !== 0 ? aggregatedFromAmount / aggregatedToAmount : 0,
+      };
+      logger.verbose(
+        `${VesuMultiplyAdapter.name}::_getIncreaseCalldata stored aggregated price info: ` +
+        `${aggregatedFromAmount} ${this.lastSwapPriceInfo.fromTokenSymbol} → ${aggregatedToAmount} ${aggregatedToSymbol}, ` +
+        `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    }
+
     logger.verbose(
       `${VesuMultiplyAdapter.name}::_getIncreaseCalldata leverSwapLimitAmount: ${leverSwapLimitAmount.toWei()}`
     );
@@ -784,6 +801,17 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     };
   }
 
+  // private _setLastSwapPriceAsNoSwap(): void {
+  //   this.lastSwapPriceInfo = {
+  //     source: "no-swap",
+  //     fromTokenSymbol: this.config.collateral.symbol,
+  //     toTokenSymbol: this.config.debt.symbol,
+  //     fromAmount: 0,
+  //     toAmount: 0,
+  //     effectivePrice: 0,
+  //   };
+  // }
+
   private async _buildDecreaseLikeCalldata(params: {
     subMargin: Web3Number;
     debtToRepayAbs: Web3Number;
@@ -796,6 +824,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const collateralToken = this.config.collateral;
     const debtToken = this.config.debt;
     const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
     const ekuboQuoter = new EkuboQuoter(
       this.config.networkConfig,
       this.config.pricer
@@ -805,6 +834,9 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     let leverSwapWeights: Web3Number[] = [];
     let leverSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
     let leverCollateralUsed = Web3Number.fromWei(0, collateralToken.decimals);
+    let aggregatedFromAmount = 0; // collateral sold
+    let aggregatedToAmount = 0; // debt bought
+    let executedSwapCount = 0;
 
     if (params.closePosition) {
       const debtQuote = await ekuboQuoter.getQuoteExactOutput(
@@ -825,6 +857,10 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         collateralToken.decimals
       ).abs();
       leverSwapLimitAmount = leverCollateralUsed.multipliedBy(1 + this.maxSlippage);
+      aggregatedFromAmount += leverCollateralUsed.toNumber();
+      aggregatedToAmount += params.debtToRepayAbs.abs().toNumber();
+      executedSwapCount += 1;
+
     } else {
       if (params.collateralPrice === undefined || params.debtPrice === undefined) {
         throw new Error(
@@ -851,19 +887,9 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         )
           .abs()
           .toNumber();
-        this.lastSwapPriceInfo = {
-          source: "ekubo",
-          fromTokenSymbol: collateralToken.symbol,
-          toTokenSymbol: debtToken.symbol,
-          fromAmount: inputAmt,
-          toAmount: outputAmt,
-          effectivePrice: outputAmt !== 0 ? outputAmt / inputAmt : 0,
-        };
-        logger.verbose(
-          `${VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata stored price info: ` +
-          `${inputAmt} ${collateralToken.symbol} → ${outputAmt} ${debtToken.symbol}, ` +
-          `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`
-        );
+        aggregatedFromAmount += inputAmt;
+        aggregatedToAmount += outputAmt;
+        executedSwapCount += 1;
 
         leverSwap = ekuboQuoter.getVesuMultiplyQuote(
           leverSwapQuote,
@@ -893,6 +919,9 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const withdrawSwapWeights: Web3Number[] = [];
 
     if (params.outputToken && !params.outputToken.address.eq(collateralToken.address)) {
+      // bcz, last swap price is configured to be common between withdraw swap and lever swap,
+      // hence need same tokens in both
+      assert(params.outputToken.address.eq(debtToken.address), 'Withdraw output token must be the same as debt token');
       const residualCollateral = params.closePosition
         ? params.existingCollateral.minus(leverCollateralUsed)
         : params.subMargin;
@@ -911,6 +940,13 @@ export class VesuMultiplyAdapter extends BaseAdapter<
           );
           withdrawSwap = built.swaps;
           withdrawSwapWeights.push(...built.weights);
+          const withdrawOutputAmount = Web3Number.fromWei(
+            withdrawQuote.total_calculated,
+            params.outputToken.decimals
+          ).abs().toNumber();
+          aggregatedFromAmount += residualCollateral.toNumber();
+          aggregatedToAmount += withdrawOutputAmount;
+          executedSwapCount += 1;
           const estimatedOutput = residualCollateral
             .multipliedBy(params.collateralPrice)
             .dividedBy(outputTokenPrice.price);
@@ -921,6 +957,24 @@ export class VesuMultiplyAdapter extends BaseAdapter<
       }
     }
 
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: collateralToken.symbol,
+        toTokenSymbol: debtToken.symbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedFromAmount !== 0 ? aggregatedToAmount / aggregatedFromAmount : 0,
+      };
+      logger.verbose(
+        `${VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata stored aggregated price info: ` +
+        `${aggregatedFromAmount} ${collateralToken.symbol} → ${aggregatedToAmount} ${debtToken.symbol}, ` +
+        `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    } else {
+      this.lastSwapPriceInfo = null;
+    }
+
     logger.debug(
       `${VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata leverSwapCount=${leverSwap.length}, withdrawSwapCount=${withdrawSwap.length}, withdrawSwapLimitAmount=${withdrawSwapLimitAmount.toNumber()}, subMargin=${params.subMargin.toNumber()}`,
     );

package/src/strategies/vesu-extended-strategy/services/executionService.ts

@@ -3,7 +3,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo, Protocols } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
 import { ERC20 } from "@/modules";
-import { logger, StandardMerkleTree, StarknetCallParser } from "@/utils";
+import { assert, logger, StandardMerkleTree, StarknetCallParser } from "@/utils";
 import { ExtendedAdapter } from "../../universal-adapters/extended-adapter";
 import { VesuMultiplyAdapter } from "../../universal-adapters/vesu-multiply-adapter";
 import {
@@ -12,7 +12,6 @@ import {
   VesuModifyPositionWithdrawParams,
 } from "../../universal-adapters/vesu-modify-position-adapter";
 import { AvnuAdapter } from "../../universal-adapters/avnu-adapter";
-import { UsdcToUsdceAdapter } from "../../universal-adapters/usdc<>usdce-adapter";
 import { ManageCall, SwapPriceInfo } from "../../universal-adapters/baseAdapter";
 import { OpenOrder, OrderSide, OrderStatus } from "@/modules/ExtendedWrapperSDk";
 import {
@@ -71,17 +70,15 @@ const DEFAULT_EXTENDED_FILL_TIMEOUT_MS = 3000;
 export interface ExecutionConfig {
   networkConfig: IConfig;
   pricer: PricerBase;
-  vesuAdapter: VesuMultiplyAdapter;
+  vesuMultiplyAdapter: VesuMultiplyAdapter;
   vesuModifyPositionAdapter: VesuModifyPositionAdapter;
   extendedAdapter: ExtendedAdapter;
   avnuAdapter: AvnuAdapter;
-  usdcToUsdceAdapter: UsdcToUsdceAdapter;
-  usdceTransferAdapter: TokenTransferAdapter
+  usdcTransferAdapter: TokenTransferAdapter
   vaultAllocator: ContractAddr;
   walletAddress: string;
   wbtcToken: TokenInfo;
   usdcToken: TokenInfo;
-  usdceToken: TokenInfo;
 
   /**
    * Returns the strategy's merkle tree (built from all leaf adapters).
@@ -192,11 +189,10 @@ export class ExecutionService {
     this._tokenSymbols = StarknetCallParser.buildTokenSymbolLookup([
       config.wbtcToken,
       config.usdcToken,
-      config.usdceToken,
-      config.vesuAdapter.config.baseToken,
-      config.vesuAdapter.config.collateral,
-      config.vesuAdapter.config.debt,
-      config.vesuAdapter.config.marginToken,
+      config.vesuMultiplyAdapter.config.baseToken,
+      config.vesuMultiplyAdapter.config.collateral,
+      config.vesuMultiplyAdapter.config.debt,
+      config.vesuMultiplyAdapter.config.marginToken,
       config.vesuModifyPositionAdapter.config.collateral,
       config.vesuModifyPositionAdapter.config.debt,
       ...avnuTokens,
@@ -204,19 +200,18 @@ export class ExecutionService {
     this._tokenDecimals = StarknetCallParser.buildTokenDecimalsLookup([
       config.wbtcToken,
       config.usdcToken,
-      config.usdceToken,
-      config.vesuAdapter.config.baseToken,
-      config.vesuAdapter.config.collateral,
-      config.vesuAdapter.config.debt,
-      config.vesuAdapter.config.marginToken,
+      config.vesuMultiplyAdapter.config.baseToken,
+      config.vesuMultiplyAdapter.config.collateral,
+      config.vesuMultiplyAdapter.config.debt,
+      config.vesuMultiplyAdapter.config.marginToken,
       config.vesuModifyPositionAdapter.config.collateral,
       config.vesuModifyPositionAdapter.config.debt,
       ...avnuTokens,
     ]);
     this._poolNames = StarknetCallParser.buildPoolNameLookup([
       {
-        poolId: config.vesuAdapter.config.poolId.toBigInt(),
-        name: `${config.vesuAdapter.config.collateral.symbol}/${config.vesuAdapter.config.debt.symbol}`,
+        poolId: config.vesuMultiplyAdapter.config.poolId.toBigInt(),
+        name: `${config.vesuMultiplyAdapter.config.collateral.symbol}/${config.vesuMultiplyAdapter.config.debt.symbol}`,
       },
       {
         poolId: config.vesuModifyPositionAdapter.config.poolId.toBigInt(),
@@ -810,14 +805,17 @@ export class ExecutionService {
    *
    * For deposit (USDC→BTC): price = sum(USDC sold) / sum(BTC bought)
    * For withdraw (BTC→USDC): price = sum(USDC bought) / sum(BTC sold)
-   */
-  private _getNetExecutionPrice(isDeposit: boolean): number | null {
+  * @returns no-swap means, logic is fine and explicit no swap is needed
+  */
+  private _getNetExecutionPrice(isDeposit: boolean): number | null { // | 'no-swap' {
     const prices: SwapPriceInfo[] = [
       this._config.avnuAdapter.lastSwapPriceInfo,
-      this._config.vesuAdapter.lastSwapPriceInfo,
+      this._config.vesuMultiplyAdapter.lastSwapPriceInfo,
     ].filter((p): p is SwapPriceInfo => p !== null);
 
+    assert(prices.length <= 1, 'Only one swap price info is allowed');
     if (prices.length === 0) return null;
+    // if (prices[0].source === 'no-swap') return 'no-swap';
 
     if (isDeposit) {
       const totalUsdc = prices.reduce((s, p) => s + p.fromAmount, 0);
@@ -833,7 +831,7 @@ export class ExecutionService {
   /** Clears cached swap price info on all adapters to prevent stale data across cycles. */
   private _clearAdapterPriceInfo(): void {
     this._config.avnuAdapter.lastSwapPriceInfo = null;
-    this._config.vesuAdapter.lastSwapPriceInfo = null;
+    this._config.vesuMultiplyAdapter.lastSwapPriceInfo = null;
   }
 
   // ═══════════════════════════════════════════════════════════════════════════
@@ -1162,6 +1160,7 @@ export class ExecutionService {
           r.type === RouteType.VESU_MULTIPLY_DECREASE_LEVER
       );
       const netExecutionPrice = this._getNetExecutionPrice(isIncrease);
+
       let executionPrice: number;
 
       if (hasVesuSwapRoute) {
@@ -1354,7 +1353,7 @@ export class ExecutionService {
   // ── Transfer routes ─────────────────────────────────────────────────────
 
   /**
-   * WALLET_TO_EXTENDED: Deposit USDC.e from operator wallet directly to Extended.
+   * WALLET_TO_EXTENDED: Deposit USDC from operator wallet directly to Extended.
    *
    * Builds raw approve + deposit calls (NOT through the manager/merkle system)
    * because the wallet interacts with Extended directly, not via vault allocator.
@@ -1372,14 +1371,14 @@ export class ExecutionService {
       return [];
     }
 
-    const { usdceToken, extendedAdapter } = this._config;
+    const { usdcToken, extendedAdapter } = this._config;
     const extendedContract = extendedAdapter.config.extendedContract;
     const vaultId = extendedAdapter.config.vaultIdExtended;
-    const salt = Math.floor(Math.random() * 10 ** usdceToken.decimals);
+    const salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
     const uint256Amount = uint256.bnToUint256(amount.toWei());
 
     const approveCall: Call = {
-      contractAddress: usdceToken.address.address,
+      contractAddress: usdcToken.address.address,
       entrypoint: "approve",
       calldata: [
         extendedContract.address,
@@ -1407,7 +1406,7 @@ export class ExecutionService {
   }
 
   /**
-   * VA_TO_EXTENDED: Deposit USDC.e from vault allocator to Extended.
+   * VA_TO_EXTENDED: Deposit USDC from vault allocator to Extended.
    *
    * Uses the extended adapter's getDepositCall to build ManageCalls,
    * then wraps them in a merkle-verified manage call through the manager contract.
@@ -1425,55 +1424,37 @@ export class ExecutionService {
       return [];
     }
 
-    // swap call (usdc to usdce)
-    const swapCall = await this._buildAdapterManageCall(
-      this._config.usdcToUsdceAdapter,
-      true,
-      { amount },
-    );
     const manageCall = await this._buildAdapterManageCall(
       this._config.extendedAdapter,
       true,
       { amount },
     );
-    return [swapCall, manageCall];
+    return [manageCall];
   }
 
   /**
-   * WALLET_TO_VA: Transfer USDC.e from operator wallet to vault allocator.
+   * WALLET_TO_VA: Transfer USDC from operator wallet to vault allocator.
    * Caps amount by actual wallet balance.
    */
   private async _buildWalletToVACalls(
     route: TransferRoute,
   ): Promise<Call[]> {
-    const erc20 = new ERC20(this._config.networkConfig);
-    const { usdceToken, vaultAllocator, walletAddress } = this._config;
-
-    // checking balance could be unnecesary overhead. hence removed removed for now.
-
     const transferAmount = route.amount;
     if (transferAmount.lessThanOrEqualTo(0)) {
       logger.warn(
-        `${this._tag}::_buildWalletToVACalls no USDC.e in wallet to transfer`,
+        `${this._tag}::_buildWalletToVACalls no USDC in wallet to transfer`,
       );
       return [];
     }
 
-    // todo, give infinite approval to VA and extended contract
-    // for USDC.e for wallet account.
+    // todo, give infinite approval to VA and extended contract for wallet account.
 
     const transferCall = await this._buildAdapterManageCall(
-      this._config.usdceTransferAdapter,
-      false,
-      { amount: transferAmount },
-    );
-    // swap call (usdc to usdce)
-    const swapCall = await this._buildAdapterManageCall(
-      this._config.usdcToUsdceAdapter,
+      this._config.usdcTransferAdapter,
       false,
       { amount: transferAmount },
     );
-    return [transferCall, swapCall];
+    return [transferCall];
   }
 
   // ── AVNU swap routes ────────────────────────────────────────────────────
@@ -1556,12 +1537,12 @@ export class ExecutionService {
     // );
 
     const depositManageCall = await this._buildAdapterManageCall(
-      this._config.vesuAdapter,
+      this._config.vesuMultiplyAdapter,
       true,
       {
         amount: route.marginAmount,
         marginSwap: {
-          marginToken: this._config.vesuAdapter.config.marginToken, // todo, must be vault token
+          marginToken: this._config.vesuMultiplyAdapter.config.marginToken, // todo, must be vault token
         },
         leverSwap: {
           exactOutput: route.swappedCollateralAmount,
@@ -1584,11 +1565,11 @@ export class ExecutionService {
     const collateralAmount = route.marginAmount.abs();
 
     const withdrawManageCall = await this._buildAdapterManageCall(
-      this._config.vesuAdapter,
+      this._config.vesuMultiplyAdapter,
       false,
       {
         amount: collateralAmount,
-        withdrawSwap: { outputToken: this._config.vesuAdapter.config.marginToken },
+        withdrawSwap: { outputToken: this._config.vesuMultiplyAdapter.config.marginToken },
       },
     );
     return [withdrawManageCall];