@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.51

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

@@ -0,0 +1,525 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IProtocol, Protocols, TokenInfo } from "@/interfaces";
+import {
+  APYType,
+  BaseAdapter,
+  BaseAdapterConfig,
+  ManageCall,
+  PositionAmount,
+  PositionAPY,
+  PositionInfo,
+  SupportedPosition,
+} from "./baseAdapter";
+import { TokenMarketData } from "@/modules";
+import {
+  SIMPLE_SANITIZER,
+  VESU_V2_MODIFY_POSITION_SANITIZER,
+  toBigInt,
+} from "./adapter-utils";
+import { CairoCustomEnum, hash, uint256 } from "starknet";
+import {
+  VesuAdapter,
+  getVesuSingletonAddress,
+} from "./vesu-adapter";
+import {
+  VesuPositionCommonContext,
+  getVesuCommonAPY,
+  getVesuCommonMaxDeposit,
+  getVesuCommonMaxWithdraw,
+  getVesuCommonPosition,
+} from "./vesu-position-common";
+import { logger } from "@/utils";
+import { HealthFactorMath } from "@/utils/health-factor-math";
+
+type SignedDelta = {
+  amount: Web3Number;
+  isNegative: boolean;
+};
+
+export interface VesuModifyPositionDepositParams {
+  amount: Web3Number;
+  debtAmount?: Web3Number;
+}
+
+export interface VesuModifyPositionWithdrawParams {
+  amount: Web3Number;
+  debtAmount?: Web3Number;
+}
+
+export interface VesuModifyPositionAdapterConfig extends BaseAdapterConfig {
+  poolId: ContractAddr;
+  collateral: TokenInfo;
+  debt: TokenInfo;
+  targetLtv: number;
+  maxLtv: number;
+}
+
+export class VesuModifyPositionAdapter extends BaseAdapter<
+  VesuModifyPositionDepositParams,
+  VesuModifyPositionWithdrawParams
+> {
+  readonly config: VesuModifyPositionAdapterConfig;
+  readonly _vesuAdapter: VesuAdapter;
+  private readonly _tokenMarketData: TokenMarketData;
+
+  constructor(config: VesuModifyPositionAdapterConfig) {
+    super(config, VesuModifyPositionAdapter.name, Protocols.VESU);
+    this.config = config;
+    this._vesuAdapter = new VesuAdapter({
+      poolId: config.poolId,
+      collateral: config.collateral,
+      debt: config.debt,
+      vaultAllocator: config.vaultAllocator,
+      id: "",
+    });
+    this._vesuAdapter.networkConfig = this.config.networkConfig;
+    this._vesuAdapter.pricer = this.config.pricer;
+    this._tokenMarketData = new TokenMarketData(
+      this.config.pricer,
+      this.config.networkConfig,
+    );
+  }
+
+  private _prepareVesuAdapter() {
+    this._vesuAdapter.networkConfig = this.config.networkConfig;
+    this._vesuAdapter.pricer = this.config.pricer;
+  }
+
+  private _getTargetHealthFactor(): number {
+    if (this.config.targetLtv <= 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;
+  }
+
+  private _getPositionCommonContext(): VesuPositionCommonContext {
+    return {
+      adapterName: VesuModifyPositionAdapter.name,
+      protocol: this.protocol,
+      poolId: this.config.poolId,
+      collateral: this.config.collateral,
+      debt: this.config.debt,
+      networkConfig: this.config.networkConfig,
+      pricer: this.config.pricer,
+      vesuAdapter: this._vesuAdapter,
+      tokenMarketData: this._tokenMarketData,
+      targetHealthFactor: this._getTargetHealthFactor(),
+      getCache: this.getCache.bind(this),
+      setCache: this.setCache.bind(this),
+      getUSDValue: this.getUSDValue.bind(this),
+    };
+  }
+
+  private _getEffectiveMaxLtv(onchainLtv: number): number {
+    return Math.min(onchainLtv, this.config.maxLtv);
+  }
+
+  private _toSigned(amount: Web3Number, isNegative: boolean): SignedDelta {
+    if (amount.isZero()) {
+      return { amount: Web3Number.fromWei(0, amount.decimals), isNegative: false };
+    }
+    return { amount: amount.abs(), isNegative };
+  }
+
+  private _depositApproveProofReadableId(): string {
+    return `vmp_ad_c_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
+  }
+
+  private _depositModifyProofReadableId(): string {
+    return `vmp_dep_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
+  }
+
+  private _withdrawApproveProofReadableId(): string {
+    return `vmp_aw_d_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
+  }
+
+  private _withdrawModifyProofReadableId(): string {
+    return `vmp_wdr_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
+  }
+
+  private _clampWithdrawCollateral(
+    collateralDelta: SignedDelta,
+    currentCollateral: Web3Number,
+  ): SignedDelta {
+    if (!collateralDelta.isNegative) {
+      return collateralDelta;
+    }
+    if (collateralDelta.amount.greaterThan(currentCollateral)) {
+      return this._toSigned(currentCollateral, true);
+    }
+    return collateralDelta;
+  }
+
+  private _clampRepayDebt(debtDelta: SignedDelta, currentDebt: Web3Number): SignedDelta {
+    if (!debtDelta.isNegative) {
+      return debtDelta;
+    }
+    if (debtDelta.amount.greaterThan(currentDebt)) {
+      return this._toSigned(currentDebt, true);
+    }
+    return debtDelta;
+  }
+
+  private _normalizeDebtAmountFromHelper(helperAmount: Web3Number): Web3Number {
+    return new Web3Number(
+      helperAmount.abs().toFixed(this.config.debt.decimals),
+      this.config.debt.decimals,
+    );
+  }
+
+  private async _getState() {
+    const [positions, ltvConfig, prices] = await Promise.all([
+      this._vesuAdapter.getPositions(this.config.networkConfig),
+      this._vesuAdapter.getLTVConfig(this.config.networkConfig),
+      this._vesuAdapter.getAssetPrices(),
+    ]);
+    return {
+      currentCollateral: positions[0].amount,
+      currentDebt: positions[1].amount,
+      onchainLtv: ltvConfig,
+      collateralPrice: prices.collateralPrice,
+      debtPrice: prices.debtPrice,
+    };
+  }
+
+  private async _buildDefaultDepositDeltas(
+    params: VesuModifyPositionDepositParams,
+  ): Promise<{ collateral: SignedDelta; debt: SignedDelta }> {
+    const state = await this._getState();
+    const collateralToAdd = params.amount;
+    const effectiveMaxLtv = this._getEffectiveMaxLtv(state.onchainLtv);
+    const helperOutput = HealthFactorMath.getMaxDebtAmount(
+      state.currentCollateral.plus(collateralToAdd),
+      state.collateralPrice,
+      effectiveMaxLtv,
+      this._getTargetHealthFactor(),
+      state.debtPrice,
+      this.config.debt,
+    );
+    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),
+    };
+  }
+
+  private async _buildDefaultWithdrawDeltas(
+    params: VesuModifyPositionWithdrawParams,
+  ): Promise<{ collateral: SignedDelta; debt: SignedDelta }> {
+    const state = await this._getState();
+    const collateralToWithdraw = params.amount;
+    const effectiveMaxLtv = this._getEffectiveMaxLtv(state.onchainLtv);
+    const helperOutput = HealthFactorMath.getMaxDebtAmount(
+      state.currentCollateral.minus(collateralToWithdraw),
+      state.collateralPrice,
+      effectiveMaxLtv,
+      this._getTargetHealthFactor(),
+      state.debtPrice,
+      this.config.debt,
+    );
+    if (!helperOutput || helperOutput.lessThan(0)) {
+      throw new Error(`Failed to calculate max debt amount for withdraw: ${helperOutput?.toNumber()}`);
+    }
+    const normalizedDebtAmount = this._normalizeDebtAmountFromHelper(
+      helperOutput,
+    ).minus(state.currentDebt); // debt to repay.
+
+    if (normalizedDebtAmount.greaterThan(0)) { // > 0 means borrow
+      throw new Error(`Failed to calculate default withdraw debt delta: ${normalizedDebtAmount?.toNumber()}`);
+    }
+
+    let collateral = this._toSigned(collateralToWithdraw, true);
+    let debt = this._toSigned(normalizedDebtAmount, true);
+    collateral = this._clampWithdrawCollateral(collateral, state.currentCollateral);
+    debt = this._clampRepayDebt(debt, state.currentDebt);
+    return { collateral, debt };
+  }
+
+  private _amountStruct(delta: SignedDelta) {
+    return {
+      denomination: new CairoCustomEnum({ Assets: {} }),
+      value: {
+        abs: uint256.bnToUint256(delta.amount.toWei()),
+        is_negative: delta.amount.isZero() ? false : delta.isNegative,
+      },
+    };
+  }
+
+  private async _getModifyPositionCall(
+    collateralDelta: SignedDelta,
+    debtDelta: SignedDelta,
+    proofReadableId: string,
+  ): Promise<ManageCall> {
+    const { contract, isV2 } = this._vesuAdapter.getVesuSingletonContract(
+      this.config.networkConfig,
+      this.config.poolId,
+    );
+    const { addr } = getVesuSingletonAddress(this.config.poolId);
+    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),
+        }
+        : {
+          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,
+      sanitizer: isV2 ? VESU_V2_MODIFY_POSITION_SANITIZER : SIMPLE_SANITIZER,
+      call: {
+        contractAddress: addr,
+        selector: hash.getSelectorFromName("modify_position"),
+        calldata: call.calldata as bigint[],
+      },
+    };
+  }
+
+  private _getApproveCall(
+    token: TokenInfo,
+    amount: Web3Number,
+    proofReadableId: string,
+  ): ManageCall {
+    const { addr } = getVesuSingletonAddress(this.config.poolId);
+    const amount256 = uint256.bnToUint256(amount.toWei());
+    return {
+      proofReadableId,
+      sanitizer: SIMPLE_SANITIZER,
+      call: {
+        contractAddress: token.address,
+        selector: hash.getSelectorFromName("approve"),
+        calldata: [
+          addr.toBigInt(),
+          toBigInt(amount256.low.toString()),
+          toBigInt(amount256.high.toString()),
+        ],
+      },
+    };
+  }
+
+  protected async getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY> {
+    return getVesuCommonAPY(this._getPositionCommonContext(), _supportedPosition);
+  }
+
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
+    return getVesuCommonPosition(this._getPositionCommonContext(), supportedPosition);
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    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> {
+    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(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    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.poolId.toBigInt(),
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+        1n,
+        0n,
+      ];
+
+    return [
+      {
+        target: this.config.collateral.address,
+        method: "approve",
+        packedArguments: [addr.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositApproveProofReadableId(),
+      },
+      {
+        target: addr,
+        method: "modify_position",
+        packedArguments: modifyPackedArguments,
+        sanitizer: isV2 ? VESU_V2_MODIFY_POSITION_SANITIZER : SIMPLE_SANITIZER,
+        id: this._depositModifyProofReadableId(),
+      },
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    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.poolId.toBigInt(),
+        this.config.collateral.address.toBigInt(),
+        this.config.debt.address.toBigInt(),
+        this.config.vaultAllocator.toBigInt(),
+        1n,
+        0n,
+      ];
+
+    return [
+      {
+        target: this.config.debt.address,
+        method: "approve",
+        packedArguments: [addr.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._withdrawApproveProofReadableId(),
+      },
+      {
+        target: addr,
+        method: "modify_position",
+        packedArguments: modifyPackedArguments,
+        sanitizer: isV2 ? VESU_V2_MODIFY_POSITION_SANITIZER : SIMPLE_SANITIZER,
+        id: this._withdrawModifyProofReadableId(),
+      },
+    ];
+  }
+
+  async getDepositCall(params: VesuModifyPositionDepositParams): Promise<ManageCall[]> {
+    const state = await this._getState();
+
+    let collateralDelta: SignedDelta;
+    let debtDelta: SignedDelta;
+
+    if (params.debtAmount === undefined) {
+      const defaults = await this._buildDefaultDepositDeltas(params);
+      collateralDelta = defaults.collateral;
+      debtDelta = defaults.debt;
+    } else {
+      collateralDelta = this._toSigned(params.amount, false);
+      debtDelta = this._toSigned(params.debtAmount!, false);
+    }
+
+    debtDelta = this._clampRepayDebt(debtDelta, state.currentDebt);
+    if (collateralDelta.isNegative || debtDelta.isNegative) {
+      throw new Error("Invalid deposit call");
+    }
+    const collateralApproveAmount = collateralDelta.amount;
+
+    logger.verbose(`getDepositCall: collateralApproveAmount=${collateralApproveAmount.toNumber()}, debtApproveAmount=${debtDelta.amount.toNumber()}`);
+    return [
+      ...(collateralApproveAmount.gt(0)
+        ? [this._getApproveCall(this.config.collateral, collateralApproveAmount, this._depositApproveProofReadableId())]
+        : []),
+      await this._getModifyPositionCall(collateralDelta, debtDelta, this._depositModifyProofReadableId()),
+    ];
+  }
+
+  async getWithdrawCall(params: VesuModifyPositionWithdrawParams): Promise<ManageCall[]> {
+    const state = await this._getState();
+
+    let collateralDelta: SignedDelta;
+    let debtDelta: SignedDelta;
+
+    if (params.debtAmount === undefined) {
+      const defaults = await this._buildDefaultWithdrawDeltas(params);
+      collateralDelta = defaults.collateral;
+      debtDelta = defaults.debt;
+    } else {
+      collateralDelta = this._toSigned(params.amount, true);
+      debtDelta = this._toSigned(params.debtAmount!, true);
+    }
+
+    collateralDelta = this._clampWithdrawCollateral(collateralDelta, state.currentCollateral);
+    debtDelta = this._clampRepayDebt(debtDelta, state.currentDebt);
+    if ((!collateralDelta.amount.isZero() && !collateralDelta.isNegative) || (!debtDelta.amount.isZero() && !debtDelta.isNegative)) {
+      throw new Error(`Invalid withdraw call: collateralDelta=${collateralDelta.amount.toNumber()} [${collateralDelta.isNegative ? "-" : "+"}], debtDelta=${debtDelta.amount.toNumber()} [${debtDelta.isNegative ? "-" : "+"}]`);
+    }
+    const debtApproveAmount = debtDelta.amount;
+
+    return [
+      ...(debtApproveAmount.gt(0)
+        ? [this._getApproveCall(this.config.debt, debtApproveAmount, this._withdrawApproveProofReadableId())]
+        : []),
+      await this._getModifyPositionCall(collateralDelta, debtDelta, this._withdrawModifyProofReadableId()),
+    ];
+  }
+
+  async getHealthFactor(): Promise<number> {
+    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;
+  }
+}